jeni 0.2.0

data/Bugs.rdoc

@@ -0,0 +1,6 @@
+== Outstanding Bugs and Change Requests for Jeni
+
+[14-Sep-2012]
+
+  * Crashes if it tries to read a link that is a file
+  * chown and chgrp actions etc are blind to whether they are needed or not!

data/Gemfile

@@ -0,0 +1,14 @@
+# @markup ruby
+# Jeni Gemfile
+
+# enable simple colours for terminal output
+gem 'colored'
+
+# ruby interface to diff
+gem 'diffy'
+
+# to support testing:
+#gem 'rspec-mocks'
+
+# to support templating
+gem 'haml'

data/History.txt

@@ -0,0 +1,9 @@
+# @markup rdoc
+# @title Change History
+
+== History
+
+
+[jeni-0.2.0 04-Oct-2012]
+
+  Application forked from local 'jeni' due to Gam-space name clash.

data/Intro.txt

@@ -0,0 +1,3 @@
+A simple alternative to rubigen and thor that can be used to create a post-install script 
+for a gem needing more than the standard file ops covered by rubygems. It can also be 
+used for straight directories instead of gems, if required.

data/LICENCE.rdoc

@@ -0,0 +1,159 @@
+Copyright (c) 2012 Robert Sharp
+
+This software is licensed for use under the Open Software Licence v. 3.0
+The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+and below. Under the terms of this licence, all derivative works
+must themselves be licensed under the Open Software Licence v. 3.0
+
+Open Source Initiative OSI - The Open Software Licence 3.0:Licensing
+[OSI Approved Licence]
+Open Software Licence ("OSL") v. 3.0
+
+This Open Software Licence (the "Licence") applies to any original work of authorship
+(the "Original Work") whose owner (the "Licensor") has placed the following licensing
+notice adjacent to the copyright notice for the Original Work:
+
+Licensed under the Open Software Licence version 3.0
+
+1) Grant of Copyright Licence. Licensor grants You a worldwide, royalty-free, non-exclusive,
+sublicensable license, for the duration of the copyright, to do the following:
+
+a) to reproduce the Original Work in copies, either alone or as part of a collective work;
+
+b) to translate, adapt, alter, transform, modify, or arrange the Original Work, thereby
+creating derivative works ("Derivative Works") based upon the Original Work;
+
+c) to distribute or communicate copies of the Original Work and Derivative Works to
+the public, with the proviso that copies of Original Work or Derivative Works that
+You distribute or communicate shall be licensed under this Open Software Licence;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent Licence. Licensor grants You a worldwide, royalty-free, non-exclusive,
+sublicensable license, under patent claims owned or controlled by the Licensor that are
+embodied in the Original Work as furnished by the Licensor, for the duration of the
+patents, to make, use, sell, offer for sale, have made, and import the Original Work
+and Derivative Works.
+
+3) Grant of Source Code Licence. The term "Source Code" means the preferred form of
+the Original Work for making modifications to it and all available documentation
+describing how to modify the Original Work. Licensor agrees to provide a machine-readable
+copy of the Source Code of the Original Work along with each copy of the Original Work
+that Licensor distributes. Licensor reserves the right to satisfy this obligation by
+placing a machine-readable copy of the Source Code in an information repository reasonably
+calculated to permit inexpensive and convenient access by You for as long as Licensor
+continues to distribute the Original Work.
+
+4) Exclusions From Licence Grant. Neither the names of Licensor, nor the names of
+any contributors to the Original Work, nor any of their trademarks or service marks,
+may be used to endorse or promote products derived from this Original Work without
+express prior permission of the Licensor. Except as expressly stated herein, nothing
+in this Licence grants any license to Licensor's trademarks, copyrights, patents,
+trade secrets or any other intellectual property. No patent license is granted to
+make, use, sell, offer for sale, have made, or import embodiments of any patent claims
+other than the licensed claims defined in Section 2. No license is granted to the
+trademarks of Licensor even if such marks are included in the Original Work. Nothing
+in this Licence shall be interpreted to prohibit Licensor from licensing under terms
+different from this Licence any Original Work that Licensor otherwise would have a
+right to license.
+
+5) External Deployment. The term "External Deployment" means the use, distribution,
+or communication of the Original Work or Derivative Works in any way such that the
+Original Work or Derivative Works may be used by anyone other than You, whether those
+works are distributed or communicated to those persons or made available as an application
+intended for use over a network. As an express condition for the grants of license hereunder,
+You must treat any External Deployment by You of the Original Work or a Derivative Work
+as a distribution under section 1(c).
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative Works
+that You create, all copyright, patent, or trademark notices from the Source Code of
+the Original Work, as well as any notices of licensing and any descriptive text identified
+therein as an "Attribution Notice." You must cause the Source Code for any Derivative Works
+that You create to carry a prominent Attribution Notice reasonably calculated to inform
+recipients that You have modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright
+in and to the Original Work and the patent rights granted herein by Licensor are owned by
+the Licensor or are sublicensed to You under the terms of this Licence with the permission
+of the contributor(s) of those copyrights and patent rights. Except as expressly stated in
+the immediately preceding sentence, the Original Work is provided under this Licence on an
+"AS IS" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation,
+the warranties of non-infringement, merchantability or fitness for a particular purpose.
+THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY
+constitutes an essential part of this Licence. No license to the Original Work is granted
+by this Licence except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory, whether
+in tort (including negligence), contract, or otherwise, shall the Licensor be liable
+to anyone for any indirect, special, incidental, or consequential damages of any character
+arising as a result of this Licence or the use of the Original Work including, without
+limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction,
+or any and all other commercial damages or losses. This limitation of liability shall not
+apply to the extent applicable law prohibits such limitation.
+
+9) Acceptance and Termination. If, at any time, You expressly assented to this Licence,
+that assent indicates your clear and irrevocable acceptance of this Licence and all of its
+terms and conditions. If You distribute or communicate copies of the Original Work or a
+Derivative Work, You must make a reasonable effort under the circumstances to obtain the
+express assent of recipients to the terms of this Licence. This Licence conditions your
+rights to undertake the activities listed in Section 1, including your right to create
+Derivative Works based upon the Original Work, and doing so without honoring these
+terms and conditions is prohibited by copyright law and international treaty. Nothing
+in this Licence is intended to affect copyright exceptions and limitations (including
+"fair use" or "fair dealing"). This Licence shall terminate immediately and You may no
+longer exercise any of the rights granted to You by this Licence upon your failure to
+honor the conditions in Section 1(c).
+
+10) Termination for Patent Action. This Licence shall terminate automatically and
+You may no longer exercise any of the rights granted to You by this Licence as of
+the date You commence an action, including a cross-claim or counterclaim, against
+Licensor or any licensee alleging that the Original Work infringes a patent. This
+termination provision shall not apply for an action alleging patent infringement
+by combinations of the Original Work with other software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this Licence
+may be brought only in the courts of a jurisdiction wherein the Licensor resides or
+in which Licensor conducts its primary business, and under the laws of that jurisdiction
+excluding its conflict-of-law provisions. The application of the United Nations Convention
+on Contracts for the International Sale of Goods is expressly excluded. Any use of
+the Original Work outside the scope of this Licence or after its termination shall be
+subject to the requirements and penalties of copyright or patent law in the appropriate
+jurisdiction. This section shall survive the termination of this Licence.
+
+12) Attorneys' Fees. In any action to enforce the terms of this Licence or seeking
+damages relating thereto, the prevailing party shall be entitled to recover its costs
+and expenses, including, without limitation, reasonable attorneys' fees and costs
+incurred in connection with such action, including any appeal of such action. This
+section shall survive the termination of this Licence.
+
+13) Miscellaneous. If any provision of this Licence is held to be unenforceable,
+such provision shall be reformed only to the extent necessary to make it enforceable.
+
+14) Definition of "You" in This Licence. "You" throughout this Licence, whether in
+upper or lower case, means an individual or a legal entity exercising rights under,
+and complying with all of the terms of, this Licence. For legal entities, "You" includes
+any entity that controls, is controlled by, or is under common control with you. For
+purposes of this definition, "control" means (i) the power, direct or indirect, to cause
+the direction or management of such entity, whether by contract or otherwise, or (ii)
+ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise restricted or
+conditioned by this Licence or by law, and Licensor promises not to interfere with or be
+responsible for such uses by You.
+
+16) Modification of This Licence. This Licence is Copyright © 2005 Lawrence Rosen.
+Permission is granted to copy, distribute, or communicate this Licence without modification.
+Nothing in this Licence permits You to modify this Licence as applied to the Original Work
+or to Derivative Works. However, You may modify the text of this Licence and copy, distribute
+or communicate your modified version (the "Modified Licence") and apply it to other original
+works of authorship subject to the following conditions: (i) You may not indicate in any way
+that your Modified Licence is the "Open Software Licence" or "OSL" and you may not use those
+names in the name of your Modified Licence; (ii) You must replace the notice specified in the
+first paragraph above with the notice "Licensed under <insert your license name here>" or
+with a notice of your own that is not confusingly similar to the notice in this Licence;
+and (iii) You may not claim that your original works are open source software unless your
+Modified Licence has been approved by Open Source Initiative (OSI) and You comply with
+its license review and certification process.

data/README.md

@@ -0,0 +1,188 @@
+# JENI
+
+_(a.k.a Jumpin Ermin's Nifty Installer)_
+
+A simple alternative to rubigen and thor that can be used to create a post-install script 
+for a gem needing more than the standard file ops covered by rubygems. It can also be used 
+for straight directories instead of gems, if required.
+
+**GitHub:** [https://github.com/osburn-sharp/jeni](https://github.com/osburn-sharp/jeni)
+
+**RubyDoc:** [http://rdoc.info/github/osburn-sharp/jeni/frames](http://rdoc.info/github/osburn-sharp/jeni/frames)
+
+**RubyGems:** [https://rubygems.org/gems/jeni](https://rubygems.org/gems/jeni)
+
+## Usage
+
+To install, 
+
+    gem install jeni.
+    
+It is a plain library with no binaries or the like. Documentation is available from [RDoc]()
+
+## Getting Started
+
+To use, create an executable, require jeni, create an instance of `Jeni::Installer`
+using the new or new_from_gem method and a block, call whatever methods you need to install files
+etc. and then `run!` the block to do the real work. See documentation for details of available methods
+and options.
+
+### Example
+
+This is a simple example:
+
+    # start the installation block
+    Jeni::Installer.new_from_gem('my_gem') do |jeni|
+      jeni.pretend(opt[:pretend]) 
+      # copy a file
+      jeni.file('source.rb', '/etc/target.rb')
+      # create a wrapper
+      jeni.wrapper('sbin/jenerate.rb', '/usr/sbin/jenerate')
+    end.run!
+    # and run jeni
+
+### Actions
+
+Jeni has the following actions, which for a gem (new_from_gem) will look for the source relative to the gem,
+and for a directory (new) will look relative to that directory:
+
++ *{Jeni::Installer#file file}* -
+  copy a file from the source to the filesystem
+  
++ *{Jeni::Installer#directory directory}* - 
+  copy all the files in a directory to the filesystem
+  
++ *{Jeni::Installer#empty_directory empty_directory}* -
+  create an empty directory with no contents.
+  
++ *{Jeni::Installer#template template}* -
+  generate a file from a template
+  
++ *{Jeni::Installer#standard_template standard_template}* -
+  as for template, but looks in standard locations for the template file
+  
++ *{Jeni::Installer#wrapper wrapper}* - 
+  create a wrapper script that calls a gem binary/script - limited to gems only
+  
++ *{Jeni::Installer#link link}* -
+  create a link to a file
+  
++ *{Jeni::Installer#message message}* -
+  output a message to the user
+  
++ *{Jeni::Installer#user user}* -
+  add a new user to the system
+  
++ *{Jeni::Installer#group group}* -
+  add a new group to the system
+  
++ *{Jeni::Installer#file_exists? file_exists?}* -
+  check that a given file exists, and optionally that it is executable
+  
+The file, directory and template methods take an options hash, which accepts the following options:
+
++ *:chown* - change the owner of the copied file(s)
++ *:chgrp* - change the group of the copied file(s)
++ *:chmod* - change the mode of the copied file(s) which should be given in octal (e.g. 0755 and not 755 or '755')
+
+For example:
+
+    jeni.file('source.rb', '/etc/target.rb', :chown=>'robert')
+    
+If the source is a relative path then it will be looked for relative to the Installer.
+So, for a gem {Jeni::Installer.new_from_gem} it will be relative to the gem's directory and for a directory 
+{Jeni::Installer.new} it will be relative to that. If the source is an absolute path (starts with '/')
+then it will be used as given.
+    
+Global options can also be set, as defined in #{Jeni::Options}. The same options can be set using {Jeni::Optparse#optparse} 
+to automatically process command line options. Call it with ARGV instead of manually setting Jeni's options.
+
+    Jeni::Installer.new_from_gem('jeni') do |jeni|
+      jeni.optparse(ARGV)
+      jeni.file('source/jeni.rb', File.join(target_dir, 'jeni_test.rb'), :chown=>'robert')
+      jeni.file('source/jeni.rb', File.join(target_dir, 'jeni.rb'), :chown=>'robert')
+      jeni.directory('source', target_dir)
+      jeni.wrapper('source/executable', File.join(target_dir, 'executable'), :chmod=>true)
+      jeni.link('source/jeni.rb', File.join(target_dir, 'jeni_link.rb'))
+    end.run!
+
+
+## Code Walkthrough
+
+The main class is {Jeni::Installer} and the instance methods provide the actions that the installer can carry out. 
+Each method makes relevant checks (e.g. target directory is writeable) and queues one of more action requests, 
+e.g. to copy a file and then change the owner. The {Jeni::Installer#run!} method checks if any errors were
+raised by the checks and aborts with error messages if they were. Otherwise it dispatches each action method with the
+saved parameters. 
+
+The hard work is all done in {Jeni::Actions} and these methods are not intended to be directly accessible to the user.
+Each action method controls messages and any interaction with the user and then carries out the intended action if
+required. User IO is achieved through {Jeni::IO}. If interaction is required the user is prompted with a list of choices
+and the appropriate action carried out as a result. This could include, for example, printing a diff listing between
+an existing file and a new file intended to replace it.
+
+Jeni has a variety of options that can be set and are separately defined in {Jeni::Options}. Alternatively, use 
+{Jeni::Optparse#optparse} mixin to set up these options from the command line (recommended).
+
+The code is available from [GitHub](https://github.com/osburn-sharp/jeni)
+
+## Dependencies
+
+A ruby compiler - works with 1.8.7.
+
+Check the {file:Gemfile} for other dependencies.
+
+### Documentation
+
+Documentation is best viewed using Yard. Documentation is available from [Rubydoc](http://rdoc.info/github/osburn-sharp/jeni/frames)
+
+## Testing/Modifying
+
+Testing can be carried out with the GitHub sources and uses rspec. There is a complete rspec test suite 
+for the Utils module (spec/jeni_utils_spec.rb). 
+
+There is also a manual test that is an example that shows a range of possible results for a mock gem. Run this with
+
+    $ test/examples/test1.rb
+    
+The same tests are used for a source directory instead of a gem:
+  
+    $ test/examples/test2.rb
+    
+There is also a variant on the above that uses optparse and can therefore accept any of the proposed
+options:
+
+    $ test/examples/test_args -p
+    
+Will pretend. For more details:
+
+    $ test/examples/test_args --help
+    
+To test users and groups there is the following, which will fail if not run as root:
+
+    $ test/examples/test_users
+    
+## Bugs
+
+Details of any unresolved bugs and change requests are in {file:Bugs.rdoc Bugs}. Issues can be logged and tracked through
+[GitHub](https://github.com/osburn-sharp/jeni/issues).
+
+## Changelog
+
+See {file:History.txt} for a summary change history.
+
+## Author and Contact
+
+The author may be contacted by via [GitHub](http://github.com/osburn-sharp)
+
+## Copyright and Licence
+
+Copyright (c) 2012 Robert Sharp
+
+This software is licensed under the terms defined in {file:LICENCE.rdoc}
+
+## Warranty
+
+This software is provided "as is" and without any express or implied
+warranties, including, without limitation, the implied warranties of
+merchantibility and fitness for a particular purpose.

data/lib/jeni.rb

@@ -0,0 +1,374 @@
+#
+# Author:: R.J.Sharp
+# Email:: robert(a)osburn-sharp.ath.cx
+# Copyright:: Copyright (c) 2012 
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file LICENCE. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# 
+
+require 'rubygems'
+require 'jeni/utils'
+require 'jeni/actions'
+require 'jeni/io'
+require 'jeni/options'
+require 'jeni/errors'
+require 'jeni/optparse'
+
+require 'etc'
+
+# = Jeni
+#
+# A simple installer designed to support gems by installing the things
+# that gem cannot install. For example: sbin files, /etc files.
+#
+# To use Jeni, you need to create an instance in a block, use the various methods
+# to copy files etc, and run the resulting block:
+#
+#   Jeni::Installer.construct('my_gem) do |jeni|
+#     jeni.pretend
+#     jeni.file('source.rb', '/usr/sbin/target')
+#     jeni.file('etc/config.rb', '/etc/my_gem.rb', :chown=>'root')
+#   end.run!
+#
+module Jeni
+  
+  # The main class to be used by callers to construct an installation script. 
+  # See {file:README.md Readme} for full details.
+  #
+  # Included modules are:
+  #
+  # * Options - methods to allow the direct assignment of defaults etc
+  # * Optparse - process command line options using Optparse
+  # * Utils, Actions and IO - methods under the bonnet
+  class Installer
+    
+    include Jeni::Utils
+    include Jeni::Actions
+    include Jeni::IO
+    include Jeni::Options
+    include Jeni::Optparse
+    
+    extend Jeni::IO # get say for the class as well!
+    
+    # create a jeni installer instance
+    #
+    # @param [String] source_root is the path to the source to copy from etc
+    # @param [String] app_name is the name of the app being installed
+    # @yield [self] returns self
+    def initialize(source_root, app_name) 
+      @app_name = app_name
+      #@gem_spec = Gem::Specification.find_by_name(@gem_name)
+      #@gem_dir = @gem_spec.gem_dir
+      @source_root = source_root
+      @commands = []
+      @errors = {}
+      @owner = nil
+      @gem_dir = nil
+      if block_given? then
+        yield self
+      else
+        return self
+      end
+    end
+    
+    # @private
+    def set_gem(dir)
+      @gem_dir = dir
+      @gem = true
+    end
+    
+    # allow scripters to know where the gem directory is
+    attr_reader :gem_dir
+    
+    #protected :set_gem
+    
+    
+    # construct an installer to install files etc after a gem install.
+    #
+    # @param [String] gem_name is the name of the gem to install from
+    # @yield [Jeni::Installer] an instance through which options and actions can
+    #   be taken
+    #
+    def self.new_from_gem(gem_name)
+      gem_spec = Gem::Specification.find_by_name(gem_name)
+      installer = self.new(gem_spec.gem_dir, gem_name)
+      installer.set_gem(gem_spec.gem_dir)
+      if block_given? then
+        yield(installer)
+      end
+      return installer
+    rescue Gem::LoadError
+      say(:fatal, "Gem name #{gem_name} could not be found", :error)
+      return nil
+    end
+    
+    # action the commands, or not, depending on the options selected
+    def run!
+      if self.errors? then
+        unless @quiet
+          puts "There are errors in the installation, which has been cancelled:"
+          puts ""
+        end
+
+        self.each_error do |error, target|
+
+          say(error, target, :error)
+        end
+        return false
+      end
+      # no errors, so do something
+      @commands.each do |command|
+        verb = command.keys.first
+        args = command[verb]
+        case verb
+        when :mkdir
+          mkdir(args)
+        when :file
+          copy(args[0], args[1])
+        when :chown
+          chown(args[:file], args[:owner])
+        when :chgrp
+          chgrp(args[:file], args[:group])
+        when :chmod
+          chmod(args[:file], args[:mode])
+        when :generate
+          generate(args[0], args[1], args[2])
+        when :wrap
+          wrap(args[0], args[1], args[2])
+        when :link
+          link_it(args[0], args[1])
+        when :user
+          add_user(args[:name], args[:options])
+        when :group
+          add_group(args[:name], args[:options])
+        when :say
+          say(args[0], args[1], args[2])
+        end
+      end
+      
+      return true
+      
+    rescue JeniError => err
+      puts "An error has occurred. Aborting."
+      puts err.inspect
+      err.each do |el|
+        puts el
+      end
+    end
+    
+    # check that a given file exists and report an error otherwise
+    #
+    # @param [String] path to the file that must exist
+    #
+    def exists?(path)
+      check_file(path)
+    end
+    
+    # copy a file from the source, relative to the gem home to the target
+    # which is absolute
+    # 
+    # @param [String] source is the gem-relative path to the file to copy
+    # @param [String] target is an absolute path to copy to
+    # @params [Hash] opts options for copying the file
+    # @option opts [String] :chown the name of the owner
+    # @option opts [String] :chgrp the name of the group
+    # @option opts [Octal] :chmod octal bit settings for chmod
+    # 
+    # Note :chown and :chgrp override the global options e.g. {Jeni::Options#owner owner}
+    def file(source, target, opts={})
+      #gsource = File.join(@source_root, source)
+      #target_dir = File.dirname(target)
+      owner = opts[:chown] || @owner
+      chmod = opts[:chmod]
+      
+      gsource = check_file(source)
+      check_target(target, owner)
+      check_chmod(chmod)
+      
+      @commands << {:file => [gsource, target]}
+      process_options(opts, target)
+    end
+    
+    # copy all of the files in the source directory to the target directory
+    #
+    # @param (see #file)
+    # @option (see #file)
+    #
+    def directory(source, target, opts={})
+      #gsource = File.join(@source_root, source)
+      gsource = check_file(source)
+      Dir["#{gsource}/*"].each do |sourcefile|
+        src_path = sourcefile.sub(@source_root + '/', '')
+        tgt_path = sourcefile.sub(gsource + '/', '')
+        targetfile = File.join(target, tgt_path)
+        if FileTest.directory?(sourcefile) then
+          self.directory(sourcefile, targetfile)
+        else
+          self.file(sourcefile, targetfile, opts)
+        end
+
+      end
+    end
+    
+    # create an empty directory and change the owner if specified. This ignores
+    # any nomkdir setting. Do not use this method together with directory as
+    # jeni will get confused about whether the directory exists or not!
+    #
+    # @param [String] target is the absolute path of the empty directory to create
+    # @param [Hash] opts to customise the directory
+    # @option (see #file)
+    #
+    def empty_directory(target, opts={})
+      @commands << {:mkdir => target}
+      owner = opts[:chown] || @owner
+      chmod = opts[:chmod]
+      process_options(opts, target)
+    end
+    
+    # check that a file exists
+    #
+    # @param [String] file to test, relative to the source (e.g. gem)
+    # @param [Hash] options
+    # @option opts [Symbol] :executable to check if it is also executable
+    #
+    def file_exists?(file, opts={})
+      check_file(file)
+      check_executable(file) if opts.has_key?(:executable)
+      @commands << {:say => [:exists, file, :ok]}
+    end
+    
+    # create a new user
+    #
+    # @param [String] name of the new user to create
+    # @param [Hash] options for creating the user
+    # @option opts [Integer] :uid user id instead of next available
+    # @option opts [Integer] :gid group id instead of next available
+    # @option opts [String] :home path to home directory for user, defaults to /home/$user
+    # @option opts [String] :shell path to shell for user, defaults to /bin/bash
+    # @option opts [Boolean] :skip set true to skip if user exists else fail
+    #
+    def user(name, opts={})
+      skip = opts[:skip]
+      skip = check_new_user(name, opts, skip)
+      check_root(skip)
+      opts[:skip] =  skip
+      @commands << {:user => {:name => name, :options => opts}}
+    end
+    
+    # create a new group
+    #
+    # @param [String] name of the new group to create
+    # @param [Hash] options for creating the user
+    # @option opts [Integer] :gid group id instead of next available
+    # @option opts [Boolean] :skip set true to skip if user exists else fail
+    #
+    def group(name, opts={})
+      skip = opts[:skip]
+      skip = check_new_group(name, opts, skip)
+      check_root(skip)
+      opts[:skip] =  skip
+      @commands << {:group => {:name => name, :options => opts}}
+    end
+    
+    # generate a file from a template using the Haml engine for plain text input.
+    # The template is prefixed with the ':plain' directive. Variables can be
+    # passed to the template using the locals hash (see below). See {file: README.md Readme}
+    # for more details.
+    #
+    # the file can be used for anything, with ruby code inserting as #\{code\}. 
+    #
+    # @param [String] source is the path to the template to render
+    # @param [String] target is an absolute path to the generated file
+    # @param [Hash] locals is an optional hash that will be converted to local params within the template
+    # 
+    # include :chown=>'user' in the locals to change the owner as well. It will be stripped from the locals
+    # passed to the template. Similarly for :chmod and :chgrp.
+    # 
+    def template(source, target, locals={})
+      #gsource = File.join(@source_root, source)
+      #target_dir = File.dirname(target)
+      opts = Hash.new
+      opts[:chown] = locals.delete(:chown)
+      opts[:chmod] = locals.delete(:chmod)
+      opts[:chgrp] = locals.delete(:chgrp)
+      
+      gsource = check_file(source)
+      check_target(target, opts[:owner])
+      check_chmod(opts[:chmod])
+      
+      @commands << {:generate => [gsource, target, locals]}
+      process_options(opts, target)
+    end
+    
+    # as for {Jeni::Installer#template} but searches for the source template from a list of predefined
+    # directories. These are ~/.jermine/templates and /usr/local/share/templates
+    # 
+    # @param (see #template)
+    #
+    def standard_template(source, target, locals={})
+      # search for the template until it is found
+      gsource = get_template(source)
+      opts = Hash.new
+      opts[:chown] = locals.delete(:chown)
+      opts[:chmod] = locals.delete(:chmod)
+      opts[:chgrp] = locals.delete(:chgrp)
+      
+      check_target(target, opts[:owner])
+      check_chmod(opts[:chmod])
+      
+      @commands << {:generate => [gsource, target, locals]}
+      process_options(opts, target)
+    end
+    
+    # create a wrapper script at target to call source in a similar manner to Gem's wrapper
+    # 
+    # The wrapper follows the same rules as for a gem, so its shebang can be set by the original
+    # file being wrapped, or by :custom_shebang in your .gemrc
+    #
+    # @param [String] source is the relative path to the file to wrap
+    # @param [String] target is an absolute path for the wrapper
+    # @params [Hash] opts options for wrapping the file
+    # @option opts [String] :chown the name of the owner
+    #
+    def wrapper(source, target, opts={})
+      #gsource = File.join(@source_root, source)
+      owner = opts[:chown] || @owner
+      
+      check_gem(:wrapper)
+      gsource = check_file(source)
+      check_target(target, owner)
+      
+      @commands << {:wrap => [source, target, gsource]}
+      @commands << {:chmod => {:file => target, :mode => 0755}} if opts.has_key?(:chmod)
+    end
+    
+    # create a link at target to source
+    #
+    # @param [String] source is the gem-relative path to the file to link
+    # @param [String] target is an absolute path for the link
+    #
+    def link(source, target)
+      #gsource = File.expand_path(File.join(@source_root, source))
+      gsource = check_file(source)
+      check_target(target)
+      @commands << {:link => [gsource, target]}
+    end
+    
+    # output a message in the same format as other messages
+    #
+    # @param [String] action a single word describing the action taking place
+    # @param [String] message a short message concerning the action
+    # @param [Symbol] status can be :ok, :no_change, :warning or :error
+    #
+    def message(action, message, status)
+      @commands << {:say => [action, message, status]}
+    end
+
+    
+  end
+end