LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    git-for-each-ref

    
    
    

    SYNOPSIS

           git for-each-ref [--count=<count>] [--shell|--perl|--python|--tcl]
                              [--sort=<key>]\* [--format=<format>] [<pattern>...]
    
    
    

    DESCRIPTION

           Iterate over all refs that match <pattern> and show them according to
           the given <format>, after sorting them according to the given set of
           <key>. If <count> is given, stop after showing that many refs. The
           interpolated values in <format> can optionally be quoted as string
           literals in the specified host language allowing their direct
           evaluation in that language.
    
    
    

    OPTIONS

           <count>
               By default the command shows all refs that match <pattern>. This
               option makes it stop after showing that many refs.
    
           <key>
               A field name to sort on. Prefix - to sort in descending order of
               the value. When unspecified, refname is used. You may use the
               --sort=<key> option multiple times, in which case the last key
               becomes the primary key.
    
           <format>
               A string that interpolates %(fieldname) from the object pointed at
               by a ref being shown. If fieldname is prefixed with an asterisk (*)
               and the ref points at a tag object, the value for the field in the
               object tag refers is used. When unspecified, defaults to
               %(objectname) SPC %(objecttype) TAB %(refname). It also
               interpolates %% to %, and %xx where xx are hex digits interpolates
               to character with hex code xx; for example %00 interpolates to \0
               (NUL), %09 to \t (TAB) and %0a to \n (LF).
    
           <pattern>...
               If one or more patterns are given, only refs are shown that match
               against at least one pattern, either using fnmatch(3) or literally,
               in the latter case matching completely or from the beginning up to
               a slash.
    
           --shell, --perl, --python, --tcl
               If given, strings that substitute %(fieldname) placeholders are
               quoted as string literals suitable for the specified host language.
               This is meant to produce a scriptlet that can directly be 'eval'ed.
    
    
    

    FIELD NAMES

           Various values from structured fields in referenced objects can be used
           to interpolate into the resulting output, or as sort keys.
    
           For all objects, the following names can be used:
    
           refname
           upstream
               The name of a local ref which can be considered "upstream" from the
               displayed ref. Respects :short in the same way as refname above.
    
           In addition to the above, for commit and tag objects, the header field
           names (tree, parent, object, type, and tag) can be used to specify the
           value in the header field.
    
           Fields that have name-email-date tuple as its value (author, committer,
           and tagger) can be suffixed with name, email, and date to extract the
           named component.
    
           The first line of the message in a commit and tag object is subject,
           the remaining lines are body. The whole message is contents.
    
           For sorting purposes, fields with numeric values sort in numeric order
           (objectsize, authordate, committerdate, taggerdate). All other fields
           are used to sort in their byte-value order.
    
           In any case, a field name that refers to a field inapplicable to the
           object referred by the ref does not cause an error. It returns an empty
           string instead.
    
           As a special case for the date-type fields, you may specify a format
           for the date by adding one of :default, :relative, :short, :local,
           :iso8601 or :rfc2822 to the end of the fieldname; e.g.
           %(taggerdate:relative).
    
    
    

    EXAMPLES

           An example directly producing formatted text. Show the most recent 3
           tagged commits::
    
               #!/bin/sh
    
               git for-each-ref --count=3 --sort=?-*authordate? \
               --format=?From: %(*authorname) %(*authoremail)
               Subject: %(*subject)
               Date: %(*authordate)
               Ref: %(*refname)
    
               %(*body)
               ? ?refs/tags?
    
           A simple example showing the use of shell eval on the output,
           demonstrating the use of --shell. List the prefixes of all heads::
    
               #!/bin/sh
    
               git for-each-ref --shell --format="ref=%(refname)" refs/heads | \
               while read entry
               do
    
                       o=%(*objectname)
                       n=%(*authorname)
                       e=%(*authoremail)
                       s=%(*subject)
                       d=%(*authordate)
                       b=%(*body)
    
                       kind=Tag
                       if test "z$t" = z
                       then
                               # could be a lightweight tag
                               t=%(objecttype)
                               kind="Lightweight tag"
                               o=%(objectname)
                               n=%(authorname)
                               e=%(authoremail)
                               s=%(subject)
                               d=%(authordate)
                               b=%(body)
                       fi
                       echo "$kind $T points at a $t object $o"
                       if test "z$t" = zcommit
                       then
                               echo "The commit was authored by $n $e
               at $d, and titled
    
                   $s
    
               Its message reads as:
               "
                               echo "$b" | sed -e "s/^/    /"
                               echo
                       fi
               ?
    
               eval='git for-each-ref --shell --format="$fmt" \
                       --sort=?*objecttype? \
                       --sort=-taggerdate \
                       refs/tags'
               eval "$eval"
    
    
    

    Git 1.7.1 03/04/2013 GIT-FOR-EACH-REF(1)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz