easyfpm 0.1.0.pre

data/doc/samples/install_scripts/pre-delete.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+#Sample pre-delete.sh script for easyfpm : https://github.com/wanix/easyfpm.git
+#Usage for deb : https://www.debian.org/doc/debian-policy/ch-maintainerscripts.html
+#Usage for rpm : http://www.rpm.org/max-rpm-snapshot/s1-rpm-inside-scripts.html
+
+myOperation=${1}
+
+case ${myOperation} in
+  0)              #Uninstall RedHat
+                  exit 0;;
+  1)              #Upgrade RedHat
+                  exit 0;;
+  remove)         #Debian:
+                  #prerm remove
+                  #or conflictor's-prerm remove in-favour <package> <new-version>
+                  exit 0;;
+  upgrade)        #Debian:
+                  #old-prerm upgrade <new-version>
+                  exit 0;;
+  deconfigure)    #Debian:
+                  #deconfigured's-prerm deconfigure in-favour <package-being-installed> <version> [removing <conflicting-package> <version>]
+                  exit 0;;
+  failed-upgrade) #Debian:
+                  #new-prerm failed-upgrade <old-version>
+                  exit 0;;
+  \?)             #Unknown
+                  exit 1;;
+  *)              exit 1;;
+esac
+exit 0

data/doc/samples/install_scripts/pre-install.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+#Sample pre-install.sh script for easyfpm : https://github.com/wanix/easyfpm.git
+#Usage for deb : https://www.debian.org/doc/debian-policy/ch-maintainerscripts.html
+#Usage for rpm : http://www.rpm.org/max-rpm-snapshot/s1-rpm-inside-scripts.html
+
+myOperation=${1}
+
+case ${myOperation} in
+  1)             #Install RedHat
+                 exit 0;;
+  2)             #Upgrade RedHat
+                 exit 0;;
+  install)       #Debian:
+                 #new-preinst install
+                 #or new-preinst install <old-version>
+                 exit 0;;
+  upgrade)       #Debian:
+                 #new-preinst upgrade <old-version>
+                 exit 0;;
+  abort-upgrade) #Debian:
+                 #old-preinst abort-upgrade <new-version>
+                 exit 0;;
+  \?)            #Unknown
+                 exit 1;;
+  *)             exit 1;;
+esac
+exit 0

data/doc/samples/mapping.conf

@@ -0,0 +1,20 @@
+#
+# This is a mapping sample
+#
+# source file (root dir is pkg-src-dir) => destination (root dir is pkg-prefix)
+#
+
+#This example suppose we want to package an apache specific configuration
+# Tree on dev
+# myapp
+#   conf.d/myapp.conf
+#   site/<php code>
+#   doc
+# 
+# the pkg-source-dir is /home/packager/retrieve/myapp
+# the pkg-prefix is /
+
+conf.d/myapp.conf => etc/apache2/site-available/myapp.conf
+site => app/httpd/www/myapp
+doc => usr/share/doc/myapp
+

data/lib/easyfpm/commandline.rb

@@ -0,0 +1,274 @@
+###############################################################################
+## Class   : EASYFPM::CommandLine
+## Author  : Erwan SEITE
+## Aim     : Manage EASYFPM Command Line
+## Licence : GPL v2
+## Source  : https://github.com/wanix/easyfpm.git
+###############################################################################
+require "easyfpm"
+require "optparse"
+begin
+  require "unixconfigstyle"
+rescue LoadError
+  require "rubygems"
+  require "unixconfigstyle"
+end
+
+
+class EASYFPM::CommandLine
+
+  def initialize()
+    @easyfpmconf = UnixConfigStyle.new()
+    @verbose = false
+    @dryrun = false
+    @debug=false
+    @labels = []
+    parse()
+  end
+
+
+  #(private) Parse the command line arguments and create a UnixConfigStyle object
+  def parse(*args)
+    easyfpmconffiles = []
+    options = {}
+    labelListAsked = false
+    optparse = OptionParser.new do |opts|
+      opts.banner = "Usage easyfpm [options]"
+
+      opts.on("--config-file [string]", String, "Configuration file's path", " (can be declared multiple times, declarative order is priority order)") do |opt|
+        easyfpmconffiles.push(opt)
+      end
+
+      opts.on("--label [list by comma]", String, "Labels to work with", " (can be declared multiple times)") do |opt|
+        @labels.concat(opt.split(','))
+      end
+
+      opts.on("--pkg-name [string]", String, "Package name") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-name")
+      end
+
+      opts.on("--pkg-type [string]", String, "Package type") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-type")
+      end
+
+      opts.on("--pkg-version [string]", String, "Package version, example 1.0") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-version")
+      end
+ 
+      opts.on("--pkg-src-dir [string]", String, "Package source dir") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-src-dir")
+      end
+
+      opts.on("--pkg-mapping [string]", String, "Package install map file") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-mapping")
+      end
+
+      opts.on("--pkg-prefix [string]", String, "Package installation prefix") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-prefix")
+      end
+
+      opts.on("--pkg-output-dir [string]", String, "Destination dir for packages") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-output-dir")
+      end
+
+      opts.on("--pkg-description [string]", String, "Package description") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-description")
+      end
+
+      opts.on("--pkg-arch [string]", String, "Package architecture") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-arch")
+      end
+
+      opts.on("--pkg-content [string]", String, "source elements to package") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-content")
+      end
+
+      opts.on("--pkg-user [string]", String, "Owner of package's elements") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-user")
+      end
+
+      opts.on("--pkg-group [string]", String, "Group of package's elements") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-group")
+      end
+
+      opts.on("--template-activated [yes|no]", String, "Activate fpm templating mode") do |opt|
+        @easyfpmconf.addValues(opt,"template-activated")
+      end
+
+      opts.on("--template-value [string key:value]", String, "Couple key:value for fpm templating") do |opt|
+        @easyfpmconf.addValues(opt,"template-value")
+      end
+
+      opts.on("--pkg-preinst [string]", String, "Path to pre-install package script") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-preinst")
+      end
+
+      opts.on("--pkg-postinst [string]", String, "Path to post-install package script") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-postinst")
+      end
+
+      opts.on("--pkg-prerm [string]", String, "Path to pre-delete package script") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-prerm")
+      end
+
+      opts.on("--pkg-postrm [string]", String, "Path to post-delete package script") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-postrm")
+      end
+
+      opts.on("--pkg-iteration [string]", String, "Package iteration") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-iteration")
+      end
+
+      opts.on("--pkg-epoch [integer]", Integer, "Package epoch value") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-epoch")
+      end
+
+      opts.on("--easyfpm-pkg-changelog [string]", String, "Path to an easyfpm format changelog file") do |opt|
+        @easyfpmconf.addValues(opt,"easyfpm-pkg-changelog")
+      end
+
+      opts.on("--pkg-vendor [string]", String, "Package vendor name") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-vendor")
+      end
+
+      opts.on("--pkg-url [string]", String, "Package vendor url") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-url")
+      end
+
+      opts.on("--pkg-license [string]", String, "Package license") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-license")
+      end
+
+      opts.on("--pkg-config-files [string]", String, "Files or directories considered as conf in the targeted OS", " (can be declared multiple time)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-config-files")
+      end
+
+      opts.on("--pkg-depends [string]", String, "Package dependancie"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-depends")
+      end
+
+      opts.on("--pkg-suffix [string]", String, "Package suffix") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-suffix")
+      end
+
+      opts.on("--pkg-changelog [string]", String, "Package changelog (in the wanted format for the package)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-changelog")
+      end
+
+      opts.on("--pkg-force [yes|no]", String, "Force package generation even if the same name exists") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-force")
+      end
+
+      opts.on("--pkg-category [string]", String, "Category for this package") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-category")
+      end
+
+      opts.on("--pkg-provides [string]", String, "A tag of what provides this package"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-provides")
+      end
+
+      opts.on("--pkg-conflicts [string]", String, "Other packages that conflict with that one"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-conflicts")
+      end
+
+      opts.on("--pkg-recommends [string]", String, "Other package to recommend"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-recommends")
+      end
+
+      opts.on("--pkg-suggests [string]", String, "Other package to suggests"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-suggests")
+      end
+
+      opts.on("--pkg-directories [string]", String, "Mark recursively a directory on the targeted system as being owned by the package"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-directories")
+      end
+
+      opts.on("--pkg-maintainer [string]", String, "The maintainer of this package") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-maintainer")
+      end
+
+      opts.on("--pkg-compression [string]", String, "The compression to use with this package (may not be possible)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-compression")
+      end
+
+      opts.on("--pkg-priority [string]", String, "The package 'priority' (depends of the targetted package type") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-priority")
+      end
+
+      opts.on("--pkg-replaces [string]", String, "Other packages this package replace"," (can be declared multiple times)") do |opt|
+        @easyfpmconf.addValues(opt,"pkg-replaces")
+      end
+
+      opts.on("-v", "--verbose", "Verbose mode") do |opt|
+        @verbose = true;
+      end
+
+      opts.on("--debug", "Debug mode") do |opt|
+        @debug = true;
+      end
+
+      opts.on("-n", "--dry-run", "Do not exec fpm, juste print what would be done") do |opt|
+        @dryrun = true;
+      end
+
+      opts.on("--version", "Display version and quit") do |opt|
+        puts "easyfpm version #{EASYFPM::VERSION}"
+        exit
+      end
+
+      opts.on("--label-list", String, "Display the availables labels and quit") do |opt|
+        labelListAsked=true
+      end
+
+      opts.on("--help", "Display help and quit") do |opt|
+        puts opts
+        exit
+      end
+    end #OptionParser.new do
+    
+    optparse.parse!
+    easyfpmconffiles.each do |conffile|
+      @easyfpmconf.push_unix_config_file(conffile)
+    end
+    if labelListAsked
+      labels = @easyfpmconf.getSections()
+      if labels.empty?
+        puts "No labels available"
+      else
+        puts "Availables labels :"
+        labels.each do |label|
+          puts " - "+label
+        end
+      end
+      exit
+    end
+  end #parse
+  private :parse
+
+  # For debugging purpose, print the UnixConfigStyle object for this instance
+  def print()
+    @easyfpmconf.print()
+  end #print
+
+  # Run the command line given
+  #def run(*args)
+  def run()
+    returnCode=true
+    if @labels.empty?
+      easyfpmpkg = EASYFPM::Packaging.new(@easyfpmconf)
+      easyfpmpkg.verbose = @verbose
+      easyfpmpkg.dryrun = @dryrun
+      easyfpmpkg.debug = @debug
+      returnCode=false unless easyfpmpkg.makeAll()
+    else
+      @labels.each do |label|
+        easyfpmpkg = EASYFPM::Packaging.new(@easyfpmconf,label)
+        easyfpmpkg.verbose = @verbose
+        easyfpmpkg.dryrun = @dryrun
+        easyfpmpkg.debug = @debug
+        returnCode=false unless easyfpmpkg.make(label)
+      end
+    end
+    return returnCode
+  end #run
+end

data/lib/easyfpm/configuration.rb

@@ -0,0 +1,274 @@
+###############################################################################
+## Class   : EASYFPM::Configuration
+## Author  : Erwan SEITE
+## Aim     : Manage EASYFPM Conf
+## Licence : GPL v2
+## Source  : https://github.com/wanix/easyfpm.git
+###############################################################################
+require "easyfpm/exceptions"
+begin
+  require "unixconfigstyle"
+rescue LoadError
+  require "rubygems"
+  require "unixconfigstyle"
+end
+
+class EASYFPM::Configuration
+
+  @@templateVarExpReg = /(\{\{([\d\w\-]+?)\}\})/
+  @@defaultLabelName = "@@easyfpm-default@@"
+
+  attr_reader :conf
+
+  #Initialize the class
+  def initialize (unixconfigstyle, specificLabel=nil)
+    raise ArgumentError, 'the argument "unixconfigstyle" must be an UnixConfigStyle object' unless unixconfigstyle.is_a? UnixConfigStyle
+    raise ArgumentError, 'the argument "specificLabel" must be an String' unless (specificLabel.is_a? String or specificLabel == nil)
+    
+    @conf={}
+    createconf(unixconfigstyle,specificLabel)
+    raise EASYFPM::InvalidConfiguration, "No configuration found (error with the label #{specificLabel}?" if @conf.empty?
+    replaceTemplateVars()
+    raise EASYFPM::InvalidConfiguration, "Error(s) during validation" unless validate()
+  end
+
+  #Create the easyfpm struct configuration from an UnixConfigStyle object
+  def createconf(unixconfigstyle, specificLabel=nil)
+    #No work if the conf is empty
+    return nil if unixconfigstyle.isEmpty?()
+    #No work if the conf doesn't contain the wanted label
+    return nil unless ( specificLabel==nil or unixconfigstyle.sectionExists?(specificLabel) )
+    #We create an array with all keys presents in the conf
+    allkeys=unixconfigstyle.getAllKeys(specificLabel)
+    if (specificLabel == nil)
+      if unixconfigstyle.haveSections?()
+        #We have section, we create a separate conf for each one
+        unixconfigstyle.getSections().each { |section| @conf[section]={} }
+      else
+        #No sections, only the default config
+        @conf[@@defaultLabelName]={}
+      end
+    else
+      #We create config only for this specific label
+      @conf[specificLabel]={}
+    end
+    #We have our label(s)
+    #It's now time to filter the configuration and create a valid conf
+
+    #Foreach conf label
+    @conf.each_key do |label|
+      confsection=label
+      confsection=unixconfigstyle.getRootSectionName() if (label==@@defaultLabelName)
+
+      #Foreach key found
+      allkeys.each do |param|
+        #If the param has no value (???), next
+        next unless unixconfigstyle.getValues(param,confsection,true)
+        case param
+          #Params for which each member of array is a string line
+          when "pkg-description"
+            @conf[label][param]=unixconfigstyle.getValues(param,confsection,true).join("\n").strip
+         
+          #Params for which each member is a string separated with a space
+          when "pkg-content"
+            @conf[label][param]=unixconfigstyle.getValues(param,confsection,true).join(" ").strip
+           
+          #Params for which we need to keep an array:
+          when "pkg-depends","template-value","pkg-config-files","pkg-provides","pkg-conflicts","pkg-replaces","pkg-directories","pkg-recommends","pkg-suggests"
+            @conf[label][param]=unixconfigstyle.getValues(param,confsection,true)
+
+        else 
+            #For the others, the last one is the right string
+            @conf[label][param]=unixconfigstyle.getValues(param,confsection,true).last.strip
+        end #case
+      end #allkeys.each
+
+      #Now, we have specific rules :
+      #If we have a mapping AND a content, we delete the content
+      @conf[label].delete("pkg-content") if (@conf[label].has_key? "pkg-content" and @conf[label].has_key? "pkg-mapping")
+      #If we have an easyfpm-pkg-changelog AND a pkg-changelog, the pkg-changelog stay
+      @conf[label].delete("easyfpm-pkg-changelog") if (@conf[label].has_key? "easyfpm-pkg-changelog" and @conf[label].has_key? "pkg-changelog")
+
+    end #@conf.each_key
+
+    
+
+  end #createconf
+
+  # (private) replace the easyfpm vars value
+  # the recursive param is here to stop multi recursive call
+  # We limit the work to two calls
+  def replaceTemplateVars(recursive=false)
+    #We start to scan each value if a var is present
+    return false if @conf.empty?
+    newTemplateFound=false
+    @conf.keys.each do |label|
+      @conf[label].keys.each do |param|
+        if (@conf[label][param].is_a? Array)
+          #Array of String
+          @conf[label][param].each_index do |index|
+            if containTemplateVar?(@conf[label][param][index])
+              @conf[label][param][index]=replaceTemplateVar(@conf[label][param][index],label)
+              newTemplateFound=true if containTemplateVar?(@conf[label][param][index])
+            end
+          end #@conf[label][param].each_index
+        else
+          #Should be String
+          if containTemplateVar?(@conf[label][param])
+            @conf[label][param]=replaceTemplateVar(@conf[label][param],label)
+            newTemplateFound=true if containTemplateVar?(@conf[label][param])
+          end
+        end #if (@conf[myLabel][param].is_a? Array)
+      end #@conf[myLabel].keys.each
+    end #@conf.getKeys.each
+
+    #First pass done, second needed ?
+    replaceTemplateVars(true) if (recursive == false and newTemplateFound == true)
+    raise EASYFPM::LoopTemplateDetected, "Need more than two occurs of function replaceTemplateVars()" if (recursive == true and newTemplateFound == true)
+  end
+  private :replaceTemplateVars
+
+  # (private) return true if the string contain at list one var
+  def containTemplateVar?(myString)
+    return false if (myString == nil)
+    return true if myString.match(@@templateVarExpReg)
+    return false
+  end
+  private :containTemplateVar?
+
+  # (private) return a string with vars replaced if a corresponding value is found
+  def replaceTemplateVar(myString, workinglabel)
+#    return myString
+    #foreach matchdata on each string
+    myString.to_enum(:scan, @@templateVarExpReg).map { Regexp.last_match }.each do |matchData|
+      myParam=matchData[2]
+      #If we can't found the key, we stop
+      raise EASYFPM::NoTemplateFound , "the key #{myParam} is not found for label #{workinglabel}" unless @conf[workinglabel].has_key? myParam
+      #If the value is not a String, error
+      raise EASYFPM::InvalidTemplateType, "the value given by the key #{myParam} can't be a multiline one" unless @conf[workinglabel][myParam].is_a? String
+       #Replace the template with its value
+       myString.gsub!(matchData[1],@conf[workinglabel][myParam])
+    end #myString.to_enum(:scan...
+    return myString
+  end
+  private :replaceTemplateVar
+
+  # (private) Validate the given configuration and clean it if necessary
+  def validate
+    errorlist = []
+    #We have to analyse some parameters and some ones MUST be present
+    @conf.keys.each do |label|
+      if (label == @@defaultLabelName)
+        displaylabel=""
+      else
+        displaylabel="[section "+label+"] "
+      end
+
+      #Looking for mandatory params
+      errorlist.push(displaylabel+"The parameter pkg-name (--pkg-name) MUST be given") unless @conf[label].has_key? "pkg-name"
+      errorlist.push(displaylabel+"The parameter pkg-src-dir (--pkg-src-dir) MUST be given") unless @conf[label].has_key? "pkg-src-dir"
+      errorlist.push(displaylabel+"The parameter pkg-version (--pkg-version) MUST be given") unless @conf[label].has_key? "pkg-version"
+      errorlist.push(displaylabel+"One of the two parameters pkg-content (--pkg-content) or pkg-mapping (--pkg-mapping) MUST be given") unless (@conf[label].has_key? "pkg-content" or @conf[label].has_key? "pkg-mapping")
+      errorlist.push(displaylabel+"The parameter pkg-type (--pkg-type) MUST be given") unless @conf[label].has_key? "pkg-type"
+
+      @conf[label].keys.each do |param|
+        case param
+          #these parameters are directories which must exists and be readable
+          when "pkg-src-dir"
+            errorlist.push(displaylabel+"The directory #{@conf[label][param]} (given by --#{param}) MUST exists") unless File.directory?(@conf[label][param])
+
+          #pkg-content can be replaced by pkg-mapping (higher priority for this last one)
+          #If no mapping, all the files or directories given must existsi and be readable in pkg-src-dir
+          when "pkg-content"
+            next unless @conf[label].has_key? "pkg-src-dir"
+            #If we already have an error on pkg-src-dir, next
+            next unless File.directory?(@conf[label]["pkg-src-dir"])
+            @conf[label][param].split.each do |fileOrDir|
+              errorlist.push(displaylabel+"The file (or directory) #{@conf[label]["pkg-src-dir"]}/#{fileOrDir} (given by --pkg-content) MUST be readable") unless (File.readable?(@conf[label]["pkg-src-dir"]+"/"+fileOrDir))
+            end
+
+          #the followings parameters must be readable files
+          when "pkg-mapping","easyfpm-pkg-changelog","pkg-changelog","pkg-preinst","pkg-postinst","pkg-prerm","pkg-postrm"
+             errorlist.push(displaylabel+"The file #{@conf[label][param]} (given by --#{param}) MUST be readable") unless (File.readable?(@conf[label][param]))
+
+          #the following parameters must be writable directories
+          when "pkg-output-dir"
+            errorlist.push(displaylabel+"The directory #{@conf[label][param]} (given by --#{param}) MUST exists and be writable") unless (File.directory?(@conf[label][param]) and File.writable?(@conf[label][param]))
+
+          #The following parameters should be only yes or no
+          when "template-activated", "pkg-force"
+            errorlist.push(displaylabel+"The param #{param} should accept only 'yes' or 'no' (and not #{@conf[label][param]})") unless (@conf[label][param].downcase == "yes" or @conf[label][param].downcase == "no")
+        end #case param
+      end #conf[label].keys.each do
+    end #@conf.keys.each
+    
+    unless errorlist.empty?
+      warn("Errors in configuration detected:")
+      errorlist.each do |currenterror|
+        warn("  "+currenterror)
+      end
+      return false
+    end
+    return true
+  end #validate
+  private :validate
+
+  # Print the configuration (debugging)
+  def print(specificLabel=nil)
+    if (specificLabel == nil)
+      @conf.each_key do |label|
+        printLabelConf(label)
+      end 
+    else
+      printLabelConf(specificLabel)
+    end 
+  end
+ 
+  #Print the configuration for one label (debugging)
+  def printLabelConf(specificLabel)
+    if (specificLabel == @@defaultLabelName)
+      puts "========================================"
+      puts "  Default package conf"
+      puts "========================================"
+    else
+      puts "========================================"
+      puts "  Configuration label #{specificLabel}"
+      puts "========================================"
+    end
+    @conf[specificLabel].each_key do |param|
+      header="<"+param+"> : "
+      if @conf[specificLabel][param].is_a? Array
+        puts header+@conf[specificLabel][param][0]
+        subheader=" "*header.length()
+        index=1
+        while index < @conf[specificLabel][param].length()
+          puts subheader+@conf[specificLabel][param][index]
+          index += 1
+        end 
+      else
+        puts header+@conf[specificLabel][param].to_s
+      end #if @conf[specificLabel][param].is_a Array
+    end #@conf[specificLabel].each_key
+  end
+  private :printLabelConf
+
+  #return true if any labels are defined
+  def hasLabels?()
+    return false if @conf.has_key? @@defaultLabelName
+    return true
+  end
+
+  #return all labels into Array, nil if no labels
+  def getLabels()
+    return nil unless hasLabels?()
+    return @conf.keys()
+  end
+
+  #return an hash for the label configuration
+  #return nil if problem
+  def getLabelHashConf(label=nil)
+    label=@@defaultLabelName if label == nil
+    return nil unless @conf.has_key? label
+    return @conf[label]
+  end
+end

data/lib/easyfpm/exceptions.rb

@@ -0,0 +1,18 @@
+# The EASYFPM exceptions
+
+#Raised if an unknown changelog format is asked
+class EASYFPM::InvalidChangelogFormat < StandardError; end
+#Raised if a needed argument for a package is missing
+class EASYFPM::MissingArgument < StandardError; end
+#Raised if a packaging label is asked and not configured
+class EASYFPM::NoSuchSection < StandardError; end
+#Raised if a loop is detected with templates
+class EASYFPM::LoopTemplateDetected < StandardError; end
+#Raised if a template var is asked and not found
+class EASYFPM::NoTemplateFound < StandardError; end
+#Raised if a template var is not a string
+class EASYFPM::InvalidTemplateType < StandardError; end
+#Raised if a configuration is not validated
+class EASYFPM::InvalidConfiguration < StandardError; end
+#Raised if a problem is detected on the system
+class EASYFPM::InvalidEnvironment < StandardError; end