falkorlib 0.6.19 → 0.7.0

data/lib/falkorlib/config.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 ################################################################################
-# Time-stamp: <Lun 2015-03-09 12:02 svarrette>
+# Time-stamp: <Fri 2016-11-11 14:21 svarrette>
 ################################################################################
 # FalkorLib Configuration
 #
@@ -15,120 +15,124 @@ require "deep_merge"
 
 module FalkorLib #:nodoc:
 
-    class << self
-        # Yields up a configuration object when given a block.
-        # Without a block it just returns the configuration object.
-        # Uses Configatron under the covers.
-        #
-        # Example:
-        #   FalkorLib.config do |c|
-        #     c.foo = :bar
-        #   end
-        #
-        #   FalkorLib.config.foo # => :bar
-        def config(&block)
-            yield configuration if block_given?
-            configuration
-        end
+  class << self
 
-        ## initiate the configuration (with default value) if needed
-        def configuration
-            @config ||= Configatron::Store.new(options = FalkorLib::Config.default)
-        end
+    # Yields up a configuration object when given a block.
+    # Without a block it just returns the configuration object.
+    # Uses Configatron under the covers.
+    #
+    # Example:
+    #   FalkorLib.config do |c|
+    #     c.foo = :bar
+    #   end
+    #
+    #   FalkorLib.config.foo # => :bar
+    def config
+      yield configuration if block_given?
+      configuration
     end
 
+    ## initiate the configuration (with default value) if needed
+    def configuration
+      @config ||= Configatron::Store.new(FalkorLib::Config.default)
+    end
 
-    module Config #:nodoc:
-        # Defaults global settings
-        DEFAULTS = {
-                    :debug          => false,
-                    :verbose        => false,
-                    :no_interaction => false,
-                    :root           => Dir.pwd,
-                    :config_files   => {
-                                        :local   => '.falkor/config',
-                                        :private => '.falkor/private',
-                                        #:project => '.falkor/project',
-                                       },
-                    #:custom_cfg   => '.falkorlib.yaml',
-                    :rvm => {
-                             :rubies      => [ '1.9.3', '2.0.0', '2.1.0'],
-                             :version     => '1.9.3',
-                             :versionfile => '.ruby-version',
-                             :gemsetfile  => '.ruby-gemset'
-                            },
-                    :templates => {
-                                   :trashdir => '.Trash',
-                                   :puppet   => {}
-                                  },
-                    :tokens  => { :code_climate => '' },
-                    :project => {}
-                   }
-
-        module_function
-
-        ## Build the default configuration hash, to be used to initiate the default.
-        # The hash is built depending on the loaded files.
-        def default
-            res = FalkorLib::Config::DEFAULTS.clone
-            $LOADED_FEATURES.each do |path|
-                res[:git]        = FalkorLib::Config::Git::DEFAULTS        if path.include?('lib/falkorlib/git.rb')
-                res[:gitflow]    = FalkorLib::Config::GitFlow::DEFAULTS    if path.include?('lib/falkorlib/git.rb')
-                res[:versioning] = FalkorLib::Config::Versioning::DEFAULTS if path.include?('lib/falkorlib/versioning.rb')
-                if path.include?('lib/falkorlib/puppet.rb')
-                    res[:puppet]     = FalkorLib::Config::Puppet::DEFAULTS
-                    res[:templates][:puppet][:modules] = FalkorLib::Config::Puppet::Modules::DEFAULTS[:metadata]
-                end
-            end
-            # Check the potential local customizations
-            [:local, :private].each do |type|
-                custom_cfg = File.join( res[:root], res[:config_files][type.to_sym])
-                if File.exists?( custom_cfg )
-                    res.deep_merge!( load_config( custom_cfg ) )
-                end
-            end
-            res
-        end
+  end
 
-        ###### get ######
-        # Return the { local | private } FalkorLib configuration
-        # Supported options:
-        #  * :file [string] filename for the local configuration
-        ##
-        def get(dir = Dir.pwd, type = :local, options = {})
-            conffile = config_file(dir,type,options)
-            res = {}
-            res = load_config( conffile ) if File.exists?( conffile )
-            res
-        end # get
-
-        ###### get_or_save ######
-        # wrapper for get and save operations
-        ##
-        def config_file(dir = Dir.pwd, type = :local, options = {})
-            path = normalized_path(dir)
-            path = FalkorLib::Git.rootdir(path) if FalkorLib::Git.init?(path)
-            raise FalkorLib::Error, "Wrong FalkorLib configuration type" unless FalkorLib.config[:config_files].keys.include?( type.to_sym)
-            return options[:file] ? options[:file] : File.join(path, FalkorLib.config[:config_files][type.to_sym])
-        end # get_or_save
-
-        
-        ###### save ######
-        # save the { local | private } configuration on YAML format
-        # Supported options:
-        #  * :file [string] filename for the saved configuration
-        #  * :no_interaction [boolean]: do not interact
-        ##
-        def save(dir = Dir.pwd, config = {}, type = :local, options = {})
-            conffile = config_file(dir,type,options)
-            confdir  = File.dirname( conffile )
-            unless File.directory?( confdir )
-                warning "about to create the configuration directory #{confdir}"
-                really_continue?  unless options[:no_interaction]
-                run %{ mkdir -p #{confdir} }
-            end
-            store_config(conffile, config, options)
-        end # save
 
+  module Config #:nodoc:
+
+    # Defaults global settings
+    DEFAULTS = {
+      :debug          => false,
+      :verbose        => false,
+      :no_interaction => false,
+      :root           => Dir.pwd,
+      :config_files   => {
+        :local   => '.falkor/config',
+        :private => '.falkor/private',
+        #:project => '.falkor/project',
+      },
+      #:custom_cfg   => '.falkorlib.yaml',
+      :rvm => {
+        :rubies      => [ '2.3.1', '2.2.5', '2.1.10', '2.0.0', '1.9.3' ],
+        :version     => '2.1.10',
+        :versionfile => '.ruby-version',
+        :gemsetfile  => '.ruby-gemset'
+      },
+      :templates => {
+        :trashdir => '.Trash',
+        :puppet   => {}
+      },
+      :tokens  => { :code_climate => '' },
+      :project => {}
+    }
+
+    module_function
+
+    ## Build the default configuration hash, to be used to initiate the default.
+    # The hash is built depending on the loaded files.
+    def default
+      res = FalkorLib::Config::DEFAULTS.clone
+      $LOADED_FEATURES.each do |path|
+        res[:git]        = FalkorLib::Config::Git::DEFAULTS        if path.include?('lib/falkorlib/git.rb')
+        res[:gitflow]    = FalkorLib::Config::GitFlow::DEFAULTS    if path.include?('lib/falkorlib/git.rb')
+        res[:versioning] = FalkorLib::Config::Versioning::DEFAULTS if path.include?('lib/falkorlib/versioning.rb')
+        if path.include?('lib/falkorlib/puppet.rb')
+          res[:puppet] = FalkorLib::Config::Puppet::DEFAULTS
+          res[:templates][:puppet][:modules] = FalkorLib::Config::Puppet::Modules::DEFAULTS[:metadata]
+        end
+      end
+      # Check the potential local customizations
+      [:local, :private].each do |type|
+        custom_cfg = File.join( res[:root], res[:config_files][type.to_sym])
+        if File.exist?( custom_cfg )
+          res.deep_merge!( load_config( custom_cfg ) )
+        end
+      end
+      res
     end
+
+    ###### get ######
+    # Return the { local | private } FalkorLib configuration
+    # Supported options:
+    #  * :file [string] filename for the local configuration
+    ##
+    def get(dir = Dir.pwd, type = :local, options = {})
+      conffile = config_file(dir, type, options)
+      res = {}
+      res = load_config( conffile ) if File.exist?( conffile )
+      res
+    end # get
+
+    ###### get_or_save ######
+    # wrapper for get and save operations
+    ##
+    def config_file(dir = Dir.pwd, type = :local, options = {})
+      path = normalized_path(dir)
+      path = FalkorLib::Git.rootdir(path) if FalkorLib::Git.init?(path)
+      raise FalkorLib::Error, "Wrong FalkorLib configuration type" unless FalkorLib.config[:config_files].keys.include?( type.to_sym)
+      (options[:file]) ? options[:file] : File.join(path, FalkorLib.config[:config_files][type.to_sym])
+    end # get_or_save
+
+
+    ###### save ######
+    # save the { local | private } configuration on YAML format
+    # Supported options:
+    #  * :file [string] filename for the saved configuration
+    #  * :no_interaction [boolean]: do not interact
+    ##
+    def save(dir = Dir.pwd, config = {}, type = :local, options = {})
+      conffile = config_file(dir, type, options)
+      confdir  = File.dirname( conffile )
+      unless File.directory?( confdir )
+        warning "about to create the configuration directory #{confdir}"
+        really_continue?  unless options[:no_interaction]
+        run %( mkdir -p #{confdir} )
+      end
+      store_config(conffile, config, options)
+    end # save
+
+  end
+
 end # module FalkorLib

data/lib/falkorlib/error.rb

@@ -1,28 +1,39 @@
 # -*- encoding: utf-8 -*-
 ################################################################################
-# Time-stamp: <Sam 2015-01-31 21:07 svarrette>
+# Time-stamp: <Fri 2016-11-11 14:25 svarrette>
 ################################################################################
 # Falkorlib errors
 
 module FalkorLib
 
-    # Errors
-    class Error < ::StandardError
+  # Errors
+  class Error < ::StandardError
 
-        class << self
-            attr_accessor :status_code
-        end
+    class << self
 
-        def status_code
-            self.class.status_code
-        end
+      attr_accessor :status_code
+
+    end
+
+    def status_code
+      self.class.status_code
     end
 
-    class Exit             < Error; self.status_code = 0; end
-    class FalkorError      < Error; self.status_code = 1; end
-    class ExecError        < Error; self.status_code = 2; end
-    class InternalError    < Error; self.status_code = 3; end
-    class ArgumentError    < Error; self.status_code = 4; end
-    class AbortError       < Error; self.status_code = 5; end
-    class TemplateNotFound < Error; self.status_code = 6; end
+  end
+
+  # default Exit
+  class Exit             < Error; self.status_code = 0; end
+  # regular error
+  class FalkorError      < Error; self.status_code = 1; end
+  # execution error
+  class ExecError        < Error; self.status_code = 2; end
+  # internal management error
+  class InternalError    < Error; self.status_code = 3; end
+  # argument error
+  class ArgumentError    < Error; self.status_code = 4; end
+  # abording
+  class AbortError       < Error; self.status_code = 5; end
+  # template not found
+  class TemplateNotFound < Error; self.status_code = 6; end
+
 end

data/lib/falkorlib/gem_tasks.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 ################################################################################
-# Time-stamp: <Ven 2014-06-20 00:10 svarrette>
+# Time-stamp: <Fri 2016-11-11 14:28 svarrette>
 ################################################################################
 #
 # FalkorLib rake tasks to pilot Gem operations
@@ -11,18 +11,19 @@ require 'falkorlib'
 require 'falkorlib/tasks'
 
 module FalkorLib #:nodoc:
+  # Rake tasks to pilot Gem operations
+  class GemTasks
 
-    # Rake tasks to pilot Gem operations
-    class GemTasks
-        include Rake::DSL if defined? Rake::DSL
+    include Rake::DSL if defined? Rake::DSL
 
-        # Install the gem  tasks for Rake
-        def install_tasks
-            load 'falkorlib/tasks/gem.rake'
-            load 'falkorlib/tasks/yard.rake'
-            load 'falkorlib/tasks/rspec.rake'
-        end
-    end # class FalkorLib::GemTasks
+    # Install the gem  tasks for Rake
+    def install_tasks
+      load 'falkorlib/tasks/gem.rake'
+      load 'falkorlib/tasks/yard.rake'
+      load 'falkorlib/tasks/rspec.rake'
+    end
+
+  end # class FalkorLib::GemTasks
 end # module FalkorLib
 
 # Now install them ;)

data/lib/falkorlib/git.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 ################################################################################
-# Time-stamp: <Ven 2014-06-06 13:12 svarrette>
+# Time-stamp: <Wed 2016-11-09 09:15 svarrette>
 ################################################################################
 # Management of Git [flow] operations
 
@@ -10,6 +10,5 @@ module FalkorLib #:nodoc:
 
 end # module FalkorLib
 
-require "falkorlib/git/base"
-require "falkorlib/git/flow"
-
+require 'falkorlib/git/base'
+require 'falkorlib/git/flow'

data/lib/falkorlib/git/base.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 ################################################################################
-# Time-stamp: <Tue 2016-02-02 20:58 svarrette>
+# Time-stamp: <Sat 2016-11-12 12:27 svarrette>
 ################################################################################
 # Interface for the main Git operations
 #
@@ -15,441 +15,484 @@ require "pathname"
 
 include FalkorLib::Common
 
-module FalkorLib  #:nodoc:
-    module Config
-
-        # Default configuration for Git
-        module Git
-            # Git defaults for FalkorLib
-            DEFAULTS = {
-                :submodulesdir => '.submodules',
-                :submodules => {},
-                :subtrees   => {}
-            }
-        end
-    end
+module FalkorLib #:nodoc:
 
-    # Management of Git operations
+  module Config
+    # Default configuration for Git
     module Git
-        module_function
-
-        ## Check if a git directory has been initialized
-        def init?(path = Dir.pwd)
-            begin
-                g = MiniGit.new(path)
-            rescue Exception
-                return false
-            end
-            return true
-        end
 
-        ## Check if the repositories already holds some commits
-        def has_commits?(path)
-	        res = false
-	        Dir.chdir(path) do
-		        stdout, stderr, exit_status = Open3.capture3( "git rev-parse HEAD" ) 
-		        res = (exit_status == 0)
-	        end
-	        res
-        end 
-
-        ## Check the availability of a given git command
-        def command?(cmd)
-            cg = MiniGit::Capturing.new()
-            cmd_list = cg.help :a => true
-            # typical run:
-            # usage: git [--version] [--help] [-C <path>] [-c name=value]
-            #            [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
-            #            [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
-            #            [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
-            #            <command> [<args>]
-            #
-            # available git commands in '/usr/local/Cellar/git/1.8.5.2/libexec/git-core'
-            #
-            #   add   [...]   \
-            #   [...]          | The part we are interested in, delimited by '\n\n' sequence
-            #   [...]         /
-            #
-            # 'git help -a' and 'git help -g' lists available subcommands and some
-            # concept guides. See 'git help <command>' or 'git help <concept>'
-            # to read about a specific subcommand or concept
-            l = cmd_list.split("\n\n")
-            l.shift # useless first part
-            #ap l
-            subl = l.each_index.select{|i| l[i] =~ /^\s\s+/ } # find sublines that starts with at least two whitespaces
-            #ap subl
-            return false if subl.empty?
-            subl.any? { |i| l[i].split.include?(cmd) }
-        end
+      # Git defaults for FalkorLib
+      DEFAULTS = {
+        :submodulesdir => '.submodules',
+        :submodules => {},
+        :subtrees   => {}
+      }
 
-        ###
-        # Initialize a git repository
-        ## 
-        def init(path = Dir.pwd, options = {})
-            # FIXME for travis test: ensure the global git configurations
-            # 'user.email' and 'user.name' are set
-            [ 'user.name', 'user.email' ].each do |userconf|
-                if MiniGit[userconf].nil?
-                    warn "The Git global configuration '#{userconf}' is not set so"
-                    warn "you should *seriously* consider setting them by running\n\t git config --global #{userconf} 'your_#{userconf.sub(/\./, '_')}'"
-                    default_val = ENV['USER']
-                    default_val += '@domain.org' if userconf =~ /email/
-                    warn "Now putting a default value '#{default_val}' you could change later on"
-                    run %{
-                         git config --global #{userconf} "#{default_val}"
-                    }
-                    #MiniGit[userconf] = default_val
-                end
-            end
-	        exit_status = 1
-            Dir.mkdir( path ) unless Dir.exist?( path )
-	        Dir.chdir( path ) do
-		        execute "git init" unless FalkorLib.config.debug
-		        exit_status = $?.to_i
-	        end
-            # #puts "#init #{path}"
-            # Dir.chdir( "#{path}" ) do
-            #     %x[ pwd && git init ] unless FalkorLib.config.debug
-            # end
-	        exit_status
-        end
+    end
+  end
 
-        # Return the Git working tree from the proposed path (current directory by default)
-        def rootdir(path = Dir.pwd)
-            g = MiniGit.new
-            g.find_git_dir(path)[1]
-        end
+  # Management of Git operations
+  module Git
 
-        # Return the git root directory for the path (current directory by default)
-        def gitdir(path = Dir.pwd)
-            g = MiniGit.new
-            g.find_git_dir(path)[0]
-        end
+    module_function
 
-        # Create a new branch
-        def create_branch(branch, path = Dir.pwd)
-	        #ap method(__method__).parameters.map { |arg| arg[1] }
-	        g = MiniGit.new(path)
-	        error "not yet any commit performed -- You shall do one" unless has_commits?(path) 
-            g.branch "#{branch}"
-        end
+    ## Check if a git directory has been initialized
+    def init?(path = Dir.pwd)
+      begin
+        MiniGit.new(path)
+      rescue Exception
+        return false
+      end
+      true
+    end
 
-        # Delete a branch. 
-        def delete_branch(branch, path = Dir.pwd, opts = { :force => false })
-            g = MiniGit.new(path)
-	        error "'#{branch}' is not a valid existing branch" unless list_branch(path).include?( branch )
-	        g.branch (opts[:force] ? :D : :d) => "#{branch}"
-        end
+    ## Check if the repositories already holds some commits
+    def commits?(path)
+      res = false
+      Dir.chdir(path) do
+        _stdout, _stderr, exit_status = Open3.capture3( "git rev-parse HEAD" )
+        res = (exit_status.to_i.zero?)
+      end
+      res
+    end
 
-        ###### config ######
-        # Retrieve the Git configuration
-        # You can propose a pattern as key
-        # Supported options:
-        #  * :list [boolean] list all configutations
-        #  * :hash [boolean] return a Hash
-        ##
-        def config(key, dir = Dir.pwd, options = {})
-          #info "Retrieve the Git configuration"
-          res = nil
-          if (options[:list] or (key.is_a? Regexp) or (key =~ /\*/))
-            cg  = MiniGit::Capturing.new(dir)
-            res = (cg.config :list => true).split("\n")
-            res.select! { |e| e.match(key) } unless key =='*'
-            #res = res.map { |e| e.split('=') }.to_h if options[:hash]
-            res = Hash[ res.map { |e| e.split('=') } ] if options[:hash]
-          else
-            g = MiniGit.new(dir)
-            res = g[key]
-            res = { key => g[key] } if options[:hash]
-          end
-          #ap res
-          res
-        end
+    ## Check the availability of a given git command
+    def command?(cmd)
+      cg = MiniGit::Capturing.new
+      cmd_list = cg.help :a => true
+      # typical run:
+      # usage: git [--version] [--help] [-C <path>] [-c name=value]
+      #            [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
+      #            [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
+      #            [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
+      #            <command> [<args>]
+      #
+      # available git commands in '/usr/local/Cellar/git/1.8.5.2/libexec/git-core'
+      #
+      #   add   [...]   \
+      #   [...]          | The part we are interested in, delimited by '\n\n' sequence
+      #   [...]         /
+      #
+      # 'git help -a' and 'git help -g' lists available subcommands and some
+      # concept guides. See 'git help <command>' or 'git help <concept>'
+      # to read about a specific subcommand or concept
+      l = cmd_list.split("\n\n")
+      l.shift # useless first part
+      #ap l
+      subl = l.each_index.select { |i| l[i] =~ /^\s\s+/ } # find sublines that starts with at least two whitespaces
+      #ap subl
+      return false if subl.empty?
+      subl.any? { |i| l[i].split.include?(cmd) }
+    end
 
-        
-        ## Fetch the latest changes
-        def fetch(path = Dir.pwd)
-            Dir.chdir( path ) do
-                execute "git fetch --all -v"
-            end
-        end
+    ###
+    # Initialize a git repository
+    ##
+    def init(path = Dir.pwd, _options = {})
+      # FIXME: for travis test: ensure the global git configurations
+      # 'user.email' and 'user.name' are set
+      [ 'user.name', 'user.email' ].each do |userconf|
+        next unless MiniGit[userconf].nil?
+        warn "The Git global configuration '#{userconf}' is not set so"
+        warn "you should *seriously* consider setting them by running\n\t git config --global #{userconf} 'your_#{userconf.sub(/\./, '_')}'"
+        default_val = ENV['USER']
+        default_val += '@domain.org' if userconf =~ /email/
+        warn "Now putting a default value '#{default_val}' you could change later on"
+        run %(
+                       git config --global #{userconf} "#{default_val}"
+                  )
+        #MiniGit[userconf] = default_val
+      end
+      exit_status = 1
+      Dir.mkdir( path ) unless Dir.exist?( path )
+      Dir.chdir( path ) do
+        execute "git init" unless FalkorLib.config.debug
+        exit_status = $?.to_i
+      end
+      # #puts "#init #{path}"
+      # Dir.chdir( "#{path}" ) do
+      #     %x[ pwd && git init ] unless FalkorLib.config.debug
+      # end
+      exit_status
+    end
 
-        ## Get an array of the local branches present (first element is always the
-        ## current branch)
-        def list_branch(path = Dir.pwd)
-            cg = MiniGit::Capturing.new(path)
-            res = cg.branch :a => true
-            res = res.split("\n")
-            # Eventually reorder to make the first element of the array the current branch
-            i = res.find_index { |e| e =~ /^\*\s/ }
-            unless (i.nil? || i == 0)
-                res[0], res[i] = res[i], res[0]
-            end
-            res.each { |e| e.sub!(/^\*?\s+/, '')  }
-            res
-        end
+    # Return the Git working tree from the proposed path (current directory by default)
+    def rootdir(path = Dir.pwd)
+      g = MiniGit.new
+      g.find_git_dir(path)[1]
+    end
 
-        ## Get the current git branch
-        def branch?(path = Dir.pwd)
-            list_branch(path)[0]
-        end
+    # Return the git root directory for the path (current directory by default)
+    def gitdir(path = Dir.pwd)
+      g = MiniGit.new
+      g.find_git_dir(path)[0]
+    end
 
-        ## Grab a remote branch
-        def grab(branch, path = Dir.pwd, remote = 'origin')
-            exit_status = 1
-            error "no branch provided" if branch.nil?
-            remotes  = FalkorLib::Git.remotes(path)
-            branches = FalkorLib::Git.list_branch(path)
-            Dir.chdir(FalkorLib::Git.rootdir( path ) ) do
-                if branches.include? "remotes/#{remote}/#{branch}"
-                    info "Grab the branch '#{remote}/#{branch}'"
-                    exit_status = execute "git branch --set-upstream #{branch} #{remote}/#{branch}"
-                else
-                    warning "the remote branch '#{remote}/#{branch}' cannot be found"
-                end
-            end
-            exit_status
-        end
+    # Create a new branch
+    def create_branch(branch, path = Dir.pwd)
+      #ap method(__method__).parameters.map { |arg| arg[1] }
+      g = MiniGit.new(path)
+      error "not yet any commit performed -- You shall do one" unless commits?(path)
+      g.branch branch.to_s
+    end
+
+    # Delete a branch.
+    def delete_branch(branch, path = Dir.pwd, opts = { :force => false })
+      g = MiniGit.new(path)
+      error "'#{branch}' is not a valid existing branch" unless list_branch(path).include?( branch )
+      g.branch ((opts[:force]) ? :D : :d) => branch.to_s
+    end
 
-        ## Publish a branch on the remote
-        def publish(branch, path = Dir.pwd, remote = 'origin')
-            exit_status = 1
-            error "no branch provided" if branch.nil?
-            remotes  = FalkorLib::Git.remotes(path)
-            branches = FalkorLib::Git.list_branch(path)
-            Dir.chdir(FalkorLib::Git.rootdir( path ) ) do
-                if branches.include? "remotes/#{remote}/#{branch}"
-                    warning "the  remote branch '#{remote}/#{branch}' already exists"
-                else
-                    info "Publish the branch '#{branch}' on the remote '#{remote}'"
-                    exit_status = run %{
+    ###### config ######
+    # Retrieve the Git configuration
+    # You can propose a pattern as key
+    # Supported options:
+    #  * :list [boolean] list all configurations
+    #  * :hash [boolean] return a Hash
+    ##
+    def config(key, dir = Dir.pwd, options = {})
+      #info "Retrieve the Git configuration"
+      res = nil
+      if (options[:list] || (key.is_a? Regexp) || (key =~ /\*/))
+        cg  = MiniGit::Capturing.new(dir)
+        res = (cg.config :list => true).split("\n")
+        res.select! { |e| e.match(key) } unless key == '*'
+        #res = res.map { |e| e.split('=') }.to_h if options[:hash]
+        res = Hash[ res.map { |e| e.split('=') } ] if options[:hash]
+      else
+        g = MiniGit.new(dir)
+        res = g[key]
+        res = { key => g[key] } if options[:hash]
+      end
+      #ap res
+      res
+    end
+
+
+    ## Fetch the latest changes
+    def fetch(path = Dir.pwd)
+      Dir.chdir( path ) do
+        execute "git fetch --all -v"
+      end
+    end
+
+    ## Get an array of the local branches present (first element is always the
+    ## current branch)
+    def list_branch(path = Dir.pwd)
+      cg = MiniGit::Capturing.new(path)
+      res = cg.branch :a => true
+      res = res.split("\n")
+      # Eventually reorder to make the first element of the array the current branch
+      i = res.find_index { |e| e =~ /^\*\s/ }
+      res[0], res[i] = res[i], res[0] unless (i.nil? || i.zero?)
+      res.each { |e| e.sub!(/^\*?\s+/, '') }
+      res
+    end
+
+
+    ## Get the current git branch
+    def branch?(path = Dir.pwd)
+      list_branch(path)[0]
+    end
+
+    ## Grab a remote branch
+    def grab(branch, path = Dir.pwd, remote = 'origin')
+      exit_status = 1
+      error "no branch provided" if branch.nil?
+      #remotes  = FalkorLib::Git.remotes(path)
+      branches = FalkorLib::Git.list_branch(path)
+      if branches.include? "remotes/#{remote}/#{branch}"
+        info "Grab the branch '#{remote}/#{branch}'"
+        exit_status = execute_in_dir(FalkorLib::Git.rootdir( path ), "git branch --track #{branch} #{remote}/#{branch}")
+      else
+        warning "the remote branch '#{remote}/#{branch}' cannot be found"
+      end
+      exit_status
+    end
+
+    ## Publish a branch on the remote
+    def publish(branch, path = Dir.pwd, remote = 'origin')
+      exit_status = 1
+      error "no branch provided" if branch.nil?
+      #remotes  = FalkorLib::Git.remotes(path)
+      branches = FalkorLib::Git.list_branch(path)
+      Dir.chdir(FalkorLib::Git.rootdir( path ) ) do
+        if branches.include? "remotes/#{remote}/#{branch}"
+          warning "the  remote branch '#{remote}/#{branch}' already exists"
+        else
+          info "Publish the branch '#{branch}' on the remote '#{remote}'"
+          exit_status = run %(
                           git push #{remote} #{branch}:refs/heads/#{branch}
                           git fetch #{remote}
-                          git branch --set-upstream-to #{remote}/#{branch} #{branch}
-                }
-                end
-            end
-            exit_status
+                          git branch -u #{remote}/#{branch} #{branch}
+                )
         end
+      end
+      exit_status
+    end
 
-        ## List the files currently under version
-        def list_files(path = Dir.pwd)
-	        g = MiniGit.new(path)
-	        g.capturing.ls_files.split
-        end 
-
-        ## Add a file/whatever to Git and commit it
-        # Supported options:
-        # * :force [boolean]: force the add
-        def add(path, msg = "", options = {})
-	        exit_status = 0
-            dir  = File.realpath File.dirname(path)
-            root = rootdir(path)
-            relative_path_to_root = Pathname.new( File.realpath(path) ).relative_path_from Pathname.new(root)
-            real_msg = (msg.empty? ? "add '#{relative_path_to_root}'" : msg)
-            opts = '-f' if options[:force]
-            Dir.chdir( dir ) do
-		        exit_status = run %{
+    ## List the files currently under version
+    def list_files(path = Dir.pwd)
+      g = MiniGit.new(path)
+      g.capturing.ls_files.split
+    end
+
+    ## Add a file/whatever to Git and commit it
+    # Supported options:
+    # * :force [boolean]: force the add
+    def add(path, msg = "", options = {})
+      exit_status = 0
+      dir  = File.realpath(File.dirname(path))
+      root = rootdir(path)
+      relative_path_to_root = Pathname.new( File.realpath(path) ).relative_path_from Pathname.new(root)
+      real_msg = ((msg.empty?) ? "add '#{relative_path_to_root}'" : msg)
+      opts = '-f' if options[:force]
+      Dir.chdir( dir ) do
+        exit_status = run %(
                   git add #{opts} #{path}
                   git commit -s -m "#{real_msg}" #{path}
-                }
-            end
-	        exit_status.to_i
-        end
+                )
+      end
+      exit_status.to_i
+    end
 
-        ## Check if a git directory is in dirty mode
-        # git diff --shortstat 2> /dev/null | tail -n1
-        def dirty?(path = Dir.pwd)
-            g = MiniGit.new(path)
-            a = g.capturing.diff :shortstat => true
-            #ap a
-            ! a.empty?
-        end
+    ## Check if a git directory is in dirty mode
+    # git diff --shortstat 2> /dev/null | tail -n1
+    def dirty?(path = Dir.pwd)
+      g = MiniGit.new(path)
+      a = g.capturing.diff :shortstat => true
+      #ap a
+      !a.empty?
+    end
 
-        ## Get the last tag commit, or nil if no tag can be found
-        def last_tag_commit(path = Dir.pwd)
-	        res = nil
-	        g = MiniGit.new(path)
-	        # git rev-list --tags --max-count=1)
-            a = g.capturing.rev_list :tags => true, :max_count => 1
-	        a
-        end # last_tag_commit
-
-        ## List of Git remotes
-        def remotes(path = Dir.pwd)
-            g = MiniGit.new(path)
-            g.capturing.remote.split()
-        end
+    ## Get a hash table of tags under the format
+    #  { <tag> => <commit> }
+    def list_tag(path = Dir.pwd)
+      res = {}
+      cg  = MiniGit::Capturing.new(path)
+      unless (cg.tag :list => true).empty?
+        # git show-ref --tags
+        a = (cg.show_ref :tags => true).split("\n")
+        res = Hash[ a.collect { |item| item.split(' refs/tags/') } ].invert
+      end
+      res
+    end # list_tag
+
+    ## Get the last tag commit, or nil if no tag can be found
+    def last_tag_commit(path = Dir.pwd)
+      res = ""
+      g = MiniGit.new(path)
+      unless (g.capturing.tag :list => true).empty?
+        # git rev-list --tags --max-count=1
+        res = (g.capturing.rev_list :tags => true, :max_count => 1).chomp
+      end
+      res
+    end # last_tag_commit
+
+    ## Create a new tag
+    # You can add extra options to the git tag command through the opts hash.
+    # Ex:
+    #   FalkorLib::Git.tag('name', dir,  { :delete => true } )
+    #
+    def tag(name, path = Dir.pwd, opts = {})
+      g = MiniGit.new(path)
+      g.tag opts, name
+    end # tag
+
+    ## List of Git remotes
+    def remotes(path = Dir.pwd)
+      g = MiniGit.new(path)
+      g.capturing.remote.split
+    end
+
+    ## Check existence of remotes
+    def remotes?(path = Dir.pwd)
+      !remotes(path).empty?
+    end
+
+    # Create a new remote <name> targeting url <url>
+    # You can pass additional options expected by git remote add in <opts>,
+    # for instance as follows:
+    #
+    #  create_remote('origin', url, dir, { :fetch => true })
+    #
+    def create_remote(name, url, path = Dir.pwd, opts = {})
+      g = MiniGit.new(path)
+      g.remote :add, opts, name, url.to_s
+    end
 
-        ## remotes?(path = Dir.pw)
-        def remotes?(path = Dir.pwd)
-	        return ! remotes(path).empty?
-        end 
-
-        ###
-        # Initialize git submodule from the configuration
-        ##
-        def submodule_init(path = Dir.pwd, submodules = FalkorLib.config.git[:submodules], options = {})
-            exit_status  = 1
-            git_root_dir = rootdir(path)
-            if File.exists?("#{git_root_dir}/.gitmodules")
-                unless submodules.empty?
-                    # TODO: Check if it contains all submodules of the configuration
-                end
-            end
-            #ap FalkorLib.config.git
-            Dir.chdir(git_root_dir) do
-                exit_status = FalkorLib::Git.submodule_update( git_root_dir )
-                submodules.each do |subdir,conf|
-                    next if conf[:url].nil?
-                    url = conf[:url]
-                    dir = "#{FalkorLib.config.git[:submodulesdir]}/#{subdir}"
-                    branch = conf[:branch].nil? ? 'master' : conf[:branch]
-                    if File.directory?( dir )
-                      puts "  ... the git submodule '#{subdir}' is already setup."
-                    else
-                      info "adding Git submodule '#{dir}' from '#{url}'"
-                        exit_status = run %{
+    # Delete a branch.
+    # def delete_branch(branch, path = Dir.pwd, opts = { :force => false })
+    #   g = MiniGit.new(path)
+    #   error "'#{branch}' is not a valid existing branch" unless list_branch(path).include?( branch )
+    #   g.branch (opts[:force] ? :D : :d) => "#{branch}"
+    # end
+
+
+    ###
+    # Initialize git submodule from the configuration
+    ##
+    def submodule_init(path = Dir.pwd, submodules = FalkorLib.config.git[:submodules], _options = {})
+      exit_status  = 1
+      git_root_dir = rootdir(path)
+      if File.exist?("#{git_root_dir}/.gitmodules")
+        unless submodules.empty?
+          # TODO: Check if it contains all submodules of the configuration
+        end
+      end
+      #ap FalkorLib.config.git
+      Dir.chdir(git_root_dir) do
+        exit_status = FalkorLib::Git.submodule_update( git_root_dir )
+        submodules.each do |subdir, conf|
+          next if conf[:url].nil?
+          url = conf[:url]
+          dir = "#{FalkorLib.config.git[:submodulesdir]}/#{subdir}"
+          branch = (conf[:branch].nil?) ? 'master' : conf[:branch]
+          if File.directory?( dir )
+            puts "  ... the git submodule '#{subdir}' is already setup."
+          else
+            info "adding Git submodule '#{dir}' from '#{url}'"
+            exit_status = run %(
                            git submodule add -b #{branch} #{url} #{dir}
                            git commit -s -m "Add Git submodule '#{dir}' from '#{url}'" .gitmodules #{dir}
-                        }
-                    end
-                end
-            end
-            exit_status
+                        )
+          end
         end
+      end
+      exit_status
+    end
 
-        ## Update the Git submodules to the **local** registered version
-        def submodule_update(path = Dir.pwd)
-	        execute_in_dir(rootdir(path), 
-	                       %{
+    ## Update the Git submodules to the **local** registered version
+    def submodule_update(path = Dir.pwd)
+      execute_in_dir(rootdir(path),
+                     %(
                    git submodule init
-                   git submodule foreach git fetch
                    git submodule update
-            })
-        end
+            ))
+    end
 
-        ## Upgrade the Git submodules to the latest HEAD version from the remote
-        def submodule_upgrade(path = Dir.pwd)
-	         execute_in_dir(rootdir(path), 
-	                       %{
+    ## Upgrade the Git submodules to the latest HEAD version from the remote
+    def submodule_upgrade(path = Dir.pwd)
+      execute_in_dir(rootdir(path),
+                     %{
                    git submodule foreach 'git fetch origin; git checkout $(git rev-parse --abbrev-ref HEAD); git reset --hard origin/$(git rev-parse --abbrev-ref HEAD); git submodule update --recursive; git clean -dfx'
-             })	        
-        end
+             })
+    end
 
 
-        ## Initialize git subtrees from the configuration
-        def subtree_init(path = Dir.pwd)
-            raise ArgumentError, "Git 'subtree' command is not available" unless FalkorLib::Git.command? "subtree"
-            if FalkorLib.config.git[:subtrees].empty?
-                FalkorLib::Git.config_warn(:subtrees)
-                return 1
-            end
-            exit_status = 0
-            git_root_dir = rootdir(path)
-            Dir.chdir(git_root_dir) do
-                FalkorLib.config.git[:subtrees].each do |dir,conf|
-                    next if conf[:url].nil?
-                    url    = conf[:url]
-                    remote = dir.gsub(/\//, '-')
-                    branch = conf[:branch].nil? ? 'master' : conf[:branch]
-                    remotes = FalkorLib::Git.remotes
-                    unless remotes.include?( remote )
-                        info "Initialize Git remote '#{remote}' from URL '#{url}'"
-                        exit_status = execute "git remote add -f #{remote} #{url}"
-                    end
-                    unless File.directory?( File.join(git_root_dir, dir) )
-                        info "initialize Git subtree '#{dir}'"
-                        exit_status = execute "git subtree add --prefix #{dir} --squash #{remote}/#{branch}"
-                    end
-                end
-
-            end
-            exit_status
+    ## Initialize git subtrees from the configuration
+    def subtree_init(path = Dir.pwd)
+      raise ArgumentError, "Git 'subtree' command is not available" unless FalkorLib::Git.command? "subtree"
+      if FalkorLib.config.git[:subtrees].empty?
+        FalkorLib::Git.config_warn(:subtrees)
+        return 1
+      end
+      exit_status = 0
+      git_root_dir = rootdir(path)
+      Dir.chdir(git_root_dir) do
+        FalkorLib.config.git[:subtrees].each do |dir, conf|
+          next if conf[:url].nil?
+          url    = conf[:url]
+          remote = dir.gsub(/\//, '-')
+          branch = (conf[:branch].nil?) ? 'master' : conf[:branch]
+          remotes = FalkorLib::Git.remotes
+          unless remotes.include?( remote )
+            info "Initialize Git remote '#{remote}' from URL '#{url}'"
+            exit_status = execute "git remote add -f #{remote} #{url}"
+          end
+          unless File.directory?( File.join(git_root_dir, dir) )
+            info "initialize Git subtree '#{dir}'"
+            exit_status = execute "git subtree add --prefix #{dir} --squash #{remote}/#{branch}"
+          end
         end
+      end
+      exit_status
+    end
 
-        ## Check if the subtrees have been initialized.
-        ## Actually based on a naive check of sub-directory existence
-        def subtree_init?(path = Dir.pwd)
-	        res = true
-	        FalkorLib.config.git[:subtrees].keys.each do |dir| 
-		        res = res && File.directory?(File.join(path, dir)) 
-	        end
-	        res
-        end # subtree_init?
-
-
-        ## Show difference between local subtree(s) and their remotes"
-        def subtree_diff(path = Dir.pwd)
-            raise ArgumentError, "Git 'subtree' command is not available" unless FalkorLib::Git.command? "subtree"
-            if FalkorLib.config.git[:subtrees].empty?
-                FalkorLib::Git.config_warn(:subtrees)
-                return 1
-            end
-            exit_status = 0
-            git_root_dir = rootdir(path)
-            Dir.chdir(git_root_dir) do
-                FalkorLib.config.git[:subtrees].each do |dir,conf|
-                    next if conf[:url].nil?
-                    url    = conf[:url]
-                    remote = dir.gsub(/\//, '-')
-                    branch = conf[:branch].nil? ? 'master' : conf[:branch]
-                    remotes = FalkorLib::Git.remotes
-                    raise IOError, "The git remote '#{remote}' is not configured" unless remotes.include?( remote )
-                    raise IOError, "The git subtree directory '#{dir}' does not exists" unless File.directory? ( File.join(git_root_dir, dir) )
-                    info "Git diff on subtree '#{dir}' with remote '#{remote}/#{branch}'"
-                    exit_status = execute "git diff #{remote}/#{branch} #{FalkorLib::Git.branch?( git_root_dir )}:#{dir}"
-                end
-            end
-            exit_status
+    ## Check if the subtrees have been initialized.
+    ## Actually based on a naive check of sub-directory existence
+    def subtree_init?(path = Dir.pwd)
+      res = true
+      FalkorLib.config.git[:subtrees].keys.each do |dir|
+        res &&= File.directory?(File.join(path, dir))
+      end
+      res
+    end # subtree_init?
+
+
+    ## Show difference between local subtree(s) and their remotes"
+    def subtree_diff(path = Dir.pwd)
+      raise ArgumentError, "Git 'subtree' command is not available" unless FalkorLib::Git.command? "subtree"
+      if FalkorLib.config.git[:subtrees].empty?
+        FalkorLib::Git.config_warn(:subtrees)
+        return 1
+      end
+      exit_status = 0
+      git_root_dir = rootdir(path)
+      Dir.chdir(git_root_dir) do
+        FalkorLib.config.git[:subtrees].each do |dir, conf|
+          next if conf[:url].nil?
+          #url    = conf[:url]
+          remote = dir.gsub(/\//, '-')
+          branch = (conf[:branch].nil?) ? 'master' : conf[:branch]
+          remotes = FalkorLib::Git.remotes
+          raise IOError, "The git remote '#{remote}' is not configured" unless remotes.include?( remote )
+          raise IOError, "The git subtree directory '#{dir}' does not exists" unless File.directory?( File.join(git_root_dir, dir) )
+          info "Git diff on subtree '#{dir}' with remote '#{remote}/#{branch}'"
+          exit_status = execute "git diff #{remote}/#{branch} #{FalkorLib::Git.branch?( git_root_dir )}:#{dir}"
         end
+      end
+      exit_status
+    end
 
-        # Pull the latest changes, assuming the git repository is not dirty
-        def subtree_up(path = Dir.pwd)
-            error "Unable to pull subtree(s): Dirty Git repository" if FalkorLib::Git.dirty?( path )
-            exit_status = 0
-            git_root_dir = rootdir(path)
-            Dir.chdir(git_root_dir) do
-                FalkorLib.config.git[:subtrees].each do |dir,conf|
-                    next if conf[:url].nil?
-                    url    = conf[:url]
-                    remote = dir.gsub(/\//, '-')
-                    branch = conf[:branch].nil? ? 'master' : conf[:branch]
-                    remotes = FalkorLib::Git.remotes
-                    info "Pulling changes into subtree '#{dir}' using remote '#{remote}/#{branch}'"
-                    raise IOError, "The git remote '#{remote}' is not configured" unless remotes.include?( remote )
-                    info "\t\\__ fetching remote '#{remotes.join(',')}'"
-                    FalkorLib::Git.fetch( git_root_dir )
-                    raise IOError, "The git subtree directory '#{dir}' does not exists" unless File.directory? ( File.join(git_root_dir, dir) )
-                    info "\t\\__ pulling changes"
-                    exit_status = execute "git subtree pull --prefix #{dir} --squash #{remote} #{branch}"
-                    #exit_status = puts "git subtree pull --prefix #{dir} --squash #{remote} #{branch}"
-                end
-            end
-            exit_status
-        end
-        alias :subtree_pull :subtree_up
-
-        # Raise a warning message if subtree/submodule section is not present
-        def config_warn(type = :subtrees)
-            warn "You shall setup 'FalkorLib.config.git[#{type.to_sym}]' to configure #{type} as follows:"
-            warn "     FalkorLib.config.git do |c|"
-            warn "       c[#{type.to_sym}] = {"
-            warn "          '<subdir>' => {"
-            warn "             :url    => '<giturl>',"
-            warn "             :branch => 'develop'   # if different from master"
-            warn "          },"
-            warn "        }"
-            warn "     end"
-            if type == :submodules
-                warn "This will configure the Git submodule into FalkorLib.config.git.submodulesdir i.e. '#{ FalkorLib.config.git.submodulesdir}'"
-            end
+    # Pull the latest changes, assuming the git repository is not dirty
+    def subtree_up(path = Dir.pwd)
+      error "Unable to pull subtree(s): Dirty Git repository" if FalkorLib::Git.dirty?( path )
+      exit_status = 0
+      git_root_dir = rootdir(path)
+      Dir.chdir(git_root_dir) do
+        FalkorLib.config.git[:subtrees].each do |dir, conf|
+          next if conf[:url].nil?
+          #url    = conf[:url]
+          remote = dir.gsub(/\//, '-')
+          branch = (conf[:branch].nil?) ? 'master' : conf[:branch]
+          remotes = FalkorLib::Git.remotes
+          info "Pulling changes into subtree '#{dir}' using remote '#{remote}/#{branch}'"
+          raise IOError, "The git remote '#{remote}' is not configured" unless remotes.include?( remote )
+          info "\t\\__ fetching remote '#{remotes.join(',')}'"
+          FalkorLib::Git.fetch( git_root_dir )
+          raise IOError, "The git subtree directory '#{dir}' does not exists" unless File.directory?( File.join(git_root_dir, dir) )
+          info "\t\\__ pulling changes"
+          exit_status = execute "git subtree pull --prefix #{dir} --squash #{remote} #{branch}"
+          #exit_status = puts "git subtree pull --prefix #{dir} --squash #{remote} #{branch}"
         end
+      end
+      exit_status
+    end
+    alias_method :subtree_pull, :subtree_up
+
+    # Raise a warning message if subtree/submodule section is not present
+    def config_warn(type = :subtrees)
+      warn "You shall setup 'Falkorlib.config.git[#{type.to_sym}]' to configure #{type} as follows:"
+      warn "     FalkorLib.config.git do |c|"
+      warn "       c[#{type.to_sym}] = {"
+      warn "          '<subdir>' => {"
+      warn "             :url    => '<giturl>',"
+      warn "             :branch => 'develop'   # if different from master"
+      warn "          },"
+      warn "        }"
+      warn "     end"
+      if type == :submodules
+        warn "This will configure the Git submodule into FalkorLib.config.git.submodulesdir"
+        warn "i.e. '#{FalkorLib.config.git[:submodulesdir]}'" if FalkorLib.config.git[:submodulesdir]
+      end
+    end
+
+
+
 
-        
-        
 
 
+  end # module FalkorLib::Git
 
-    end # module FalkorLib::Git
 end # module FalkorLib