Module: GitVersionBump

Defined in:
lib/git-version-bump.rb

Constant Summary collapse

VERSION = 
version('git-version-bump')
MAJOR_VERSION = 
major_version('git-version-bump')
MINOR_VERSION = 
minor_version('git-version-bump')
PATCH_VERSION = 
patch_version('git-version-bump')
INTERNAL_REVISION = 
internal_revision('git-version-bump')
DATE = 
date('git-version-bump')

Class Method Summary collapse

Class Method Details

.caller_gemspec ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/git-version-bump.rb', line 9

def self.caller_gemspec
  # First up, who called us?  Because this method gets called from other
  # methods within this file, we can't just look at
  # Gem.location_of_caller, but instead we need to parse the caller
  # stack ourselves to find which gem we're trying to version all over.
  caller_file = caller.
                  map  { |l| l.split(':')[0] }.
                  find { |l| l != __FILE__ }

  # Next we grovel through all the loaded gems to try and find the gem
  # that contains the caller's file.
  Gem.loaded_specs.values.each do |spec|
    if Dir.
        glob(spec.lib_dirs_glob).
        find { |d| caller_file.index(d) == 0 }
      # The caller_file is in this
      # gem!  Woohoo!
      return spec
    end
  end

  nil
end

.date(gem = nil) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/git-version-bump.rb', line 120

def self.date(gem = nil)
  # Are we in a git tree?
  system("git status >/dev/null 2>&1")
  if $? == 0
    # Yes, we're in git.

    if dirty_tree?
      return Time.now.strftime("%F")
    else
      # Clean tree.  Date of last commit is needed.
      return `git show --format=format:%ad --date=short | head -n 1`.strip
    end
  else
    # Not in git; time to hit the gemspecs
    if gem
      return Gem.loaded_specs[gem].date.strftime("%F")
    end

    if spec = caller_gemspec
      return spec.date.strftime("%F")
    end

    raise RuntimeError,
        "GVB.date(#{gem.inspect}) called from mysterious, non-gem location."
  end
end

.dirty_tree? ⇒ Boolean

Returns:

  • (Boolean) 


2
3
4
5
6
7
 
# File 'lib/git-version-bump.rb', line 2

def self.dirty_tree?
  # Are we in a dirty, dirty tree?
  system("! git diff --no-ext-diff --quiet --exit-code || ! git diff-index --cached --quiet HEAD")

  $? == 0
end

.internal_revision(gem = nil) ⇒ Object 



114
115
116
 
# File 'lib/git-version-bump.rb', line 114

def self.internal_revision(gem = nil)
  version(gem).split('.', 4)[3].to_s
end

.major_version(gem = nil) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/git-version-bump.rb', line 72

def self.major_version(gem = nil)
  ver = version(gem)
  v   = ver.split('.')[0]
  
  unless v =~ /^[0-9]+$/
    raise ArgumentError,
            "#{v} (part of #{ver.inspect}) is not a numeric version component.  Abandon ship!"
  end
  
  return v.to_i
end

.minor_version(gem = nil) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/git-version-bump.rb', line 86

def self.minor_version(gem = nil)
  ver = version(gem)
  v   = ver.split('.')[1]
  
  unless v =~ /^[0-9]+$/
    raise ArgumentError,
            "#{v} (part of #{ver.inspect}) is not a numeric version component.  Abandon ship!"
  end
  
  return v.to_i
end

.patch_version(gem = nil) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/git-version-bump.rb', line 100

def self.patch_version(gem = nil)
  ver = version(gem)
  v   = ver.split('.')[2]
  
  unless v =~ /^[0-9]+$/
    raise ArgumentError,
            "#{v} (part of #{ver.inspect}) is not a numeric version component.  Abandon ship!"
  end
  
  return v.to_i
end

.tag_version(v) ⇒ Object 



149
150
151
152
153
154
155
156
157
158
 
# File 'lib/git-version-bump.rb', line 149

def self.tag_version(v)
  if dirty_tree?
    puts "You have uncommitted files.  Refusing to tag a dirty tree."
  else
    puts "Tagging version #{v}..."
    system("git tag -a -m 'Version v#{v}' v#{v}")
    system("git push >/dev/null 2>&1")
    system("git push --tags >/dev/null 2>&1")
  end
end

.version(gem = nil) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/git-version-bump.rb', line 33

def self.version(gem = nil)
  git_ver = `git describe --dirty --match='v[0-9]*.[0-9]*.*[0-9]' 2>/dev/null`.
              strip.
              gsub(/^v/, '').
              gsub('-', '.')
  
  # If git returned success, then it gave us a described version.
  # Success!
  return git_ver if $? == 0

  # git failed us; we're either not in a git repo or else we've never
  # tagged anything before.
  
  # Are we in a git repo with no tags?  If so, dump out our
  # super-special version and be done with it.
  system("git status >/dev/null 2>&1")
  return "0.0.0.1.ENOTAG" if $? == 0

  if gem
    return Gem.loaded_specs[gem].version.to_s
  end

  # We're not in a git repo.  This means that we need to get version
  # information out of rubygems, given only the filename of who called
  # us.  This takes a little bit of effort.

  if spec = caller_gemspec
    return spec.version.to_s
  else
    # If we got here, something went *badly* wrong -- presumably, we
    # weren't called from within a loaded gem, and so we've got *no*
    # idea what's going on.  Time to bail!
    raise RuntimeError,
          "GVB.version(#{gem.inspect}) called from mysterious, non-gem location."
  end
end