Class: Prick::Program

Inherits:
Object
  • Object
show all
Defined in:
lib/prick/program.rb

Overview

Implements the command line commands

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(quiet: false, verbose: false) ⇒ Program

Returns a new instance of Program.



12
13
14
15
 
# File 'lib/prick/program.rb', line 12

def initialize(quiet: false, verbose: false)
  @quiet = quiet
  @verbose = verbose
end

Instance Attribute Details

#quiet ⇒ Object

Returns the value of attribute quiet.



9
10
11
 
# File 'lib/prick/program.rb', line 9

def quiet
  @quiet
end

#verbose ⇒ Object

Returns the value of attribute verbose.



10
11
12
 
# File 'lib/prick/program.rb', line 10

def verbose
  @verbose
end

Instance Method Details

#backup(file = nil) ⇒ Object 



219
 
# File 'lib/prick/program.rb', line 219

def backup(file = nil) project.backup(file) end

#build(database, version, no_cache) ⇒ Object

TODO: Move to project to take advantage of cache



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/prick/program.rb', line 46

def build(database, version, no_cache)
  version = version && Version.new(version)
  into_mesg = database && "into #{database}" 
  database = database ? Database.new(database, project.user) : project.database(version)
  if version
    Git.tag?(version) or raise Error, "Can't find tag v#{version}"
    cache_file = project.cache_file(version)
    if !no_cache && File.exist?(cache_file)
      project.load(cache_file, database: database)
      mesg "Loaded v#{version}", into_mesg, "from cache"
    else
      project.build(database: database, version: version)
      project.save(cache_file, database: database)
      mesg "Built v#{version}", into_mesg
    end
  else
    project.build(database: database)
    mesg "Built current schema", into_mesg
  end
end

#cancel_release(arg) ⇒ Object 



161
162
163
 
# File 'lib/prick/program.rb', line 161

def cancel_release(arg)
  project.cancel_release(Version.new(arg))
end

#check ⇒ Object 



134
135
136
137
138
139
140
141
142
 
# File 'lib/prick/program.rb', line 134

def check
  version ||= 
      if project.prerelease? || project.migration?
        project.branch.base_version
      else
        project.branch.version
      end
  project.check_migration(version)
end

#check_clean ⇒ Object 



19
 
# File 'lib/prick/program.rb', line 19

def check_clean() Git.clean? or raise Error, "Repository is dirty - please commit your changes first" end

#create_feature(name) ⇒ Object 



189
190
191
192
193
194
 
# File 'lib/prick/program.rb', line 189

def create_feature(name)
  check_clean
  project.release? or raise "You ned to be on a release branch to create a feature"
  project.create_feature(name)
  mesg "Created feature '#{name}'"
end

#create_prerelease(arg) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/prick/program.rb', line 165

def create_prerelease(arg)
  check_clean
  if project.release?
    version = %w(major minor patch).include?(arg) ? project.version.increment(arg.to_sym) : Version.new(arg)
    project.prepare_release(commit: false)
    prerelease = project.create_prerelease(version)
    mesg "Created pre-release #{prerelease.version}"
  elsif project.prerelease?
    arg.nil? or raise Error, "Illegal number of arguments"
    prerelease = project.increment_prerelease
    mesg "Created pre-release #{prerelease.prerelease_version}"
  else
    raise Error, "You need to be on a release branch to create a pre-release"
  end
end

#create_release(arg = nil) ⇒ Object

arg can be a version numer of a relative increase (eg. ‘minor’)



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/prick/program.rb', line 145

def create_release(arg = nil)
  check_clean
  if project.release?
    arg or raise Error, "Need a version argument"
    version = compute_version(project.version, arg)
    project.create_release(Version.new(version))
    mesg project.message
  elsif project.prerelease?
    arg.nil? or raise Error, "Illegal number of arguments"
    project.create_release_from_prerelease
    mesg project.message
  else
    raise Error, "You need to be on a release or pre-release branch to create a new release"
  end
end

#include_feature(name_or_version) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
 
# File 'lib/prick/program.rb', line 196

def include_feature(name_or_version)
  check_clean
  project.prerelease? or raise Error, "You need to be on a pre-release branch to include a feature"
  version = Version.try(name_or_version) || 
      Version.new(project.branch.base_version, feature: name_or_version)
  Git.branch?(version.to_s) or raise Error, "Can't find feature #{version}"
  project.include_feature(version)
  mesg "Included feature '#{name_or_version}'"
  mesg "Please resolve eventual conflicts and then commit"
end

#info ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/prick/program.rb', line 31

def info
  if project.tag?
    puts "At v#{project.version} tag"
  else
    puts "On branch #{project.branch.name}"
  end
  puts "  Git is " + (Git.clean? ? "clean" : "dirty")
  bv = project.branch.version
  dv = project.database.version
  sv = project.branch.schema.version
  puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
  puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
end

#initialize_directory(project_name, database_user, directory) ⇒ Object 



21
22
23
24
25
26
27
28
29
 
# File 'lib/prick/program.rb', line 21

def initialize_directory(project_name, database_user, directory)
  !Project.initialized?(directory) or raise Error, "Directory #{directory} is already initialized"
  Project.initialize_directory(project_name, database_user, directory)
  if project_name != File.basename(directory)
    mesg "Initialized project #{project_name} in #{directory}"
  else
    mesg "Initialized project #{project_name}"
  end
end

#list_migrations ⇒ Object 



100
101
102
 
# File 'lib/prick/program.rb', line 100

def list_migrations
  puts project.list_migrations.sort.map(&:name)
end

#list_releases(migrations: false, cancelled: false) ⇒ Object 



96
97
98
 
# File 'lib/prick/program.rb', line 96

def list_releases(migrations: false, cancelled: false)
  puts (project.list_releases(all: cancelled) + (migrations ? project.list_migrations : [])).sort.map(&:name)
end

#list_upgrades(from = nil, to = nil) ⇒ Object 



104
105
106
107
108
109
 
# File 'lib/prick/program.rb', line 104

def list_upgrades(from = nil, to = nil)
  from = from ? Version.new(from) : project.database.version
  to = to ? Version.new(to) : project.branch.version
  branches = project.list_upgrades(from, to)
  puts branches.map(&:name)
end

#load(database, file_or_version) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/prick/program.rb', line 67

def load(database, file_or_version)
  version = Version.try(file_or_version)
  into_mesg = database && "into #{database}" 
  database = database ? Database.new(database, project.user) : project.database(version)
  if version
    file = project.cache_file(version)
    File.exist?(file) or raise Error, "Can't find #{file} - forgot to build?"
    project.load(file, database: database)
    mesg "Loaded v#{version}", into_mesg
  else
    file = file_or_version
    project.load(file, database: database)
    mesg "Loaded #{file}", into_mesg
  end
end

#make(subject) ⇒ Object 



91
92
93
94
 
# File 'lib/prick/program.rb', line 91

def make(subject)
  project.database.exist? or raise Error, "Project database is not present"
  project.make(project.database, subject)
end

#mesg(*args) ⇒ Object 



17
 
# File 'lib/prick/program.rb', line 17

def mesg(*args) puts args.compact.grep(/\S/).join(' ') if !quiet end

#prepare_diff(version = nil) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
 
# File 'lib/prick/program.rb', line 116

def prepare_diff(version = nil)
  version ||= 
      if project.prerelease? || project.migration? || project.feature?
        project.branch.base_version
      else
        project.branch.version
      end
  project.prepare_diff(version)
  mesg "Remember to update the associated SQL migration files"
end

#prepare_migration(arg) ⇒ Object 



181
182
183
184
185
186
187
 
# File 'lib/prick/program.rb', line 181

def prepare_migration(arg)
  check_clean
  version = Version.new(arg)
  project.release? or raise "You need to be on a release or migration branch to prepare a migration"
  project.prepare_migration(version)
  mesg project.message
end

#prepare_release ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/prick/program.rb', line 127

def prepare_release
  check_clean
  project.version.release? or raise Error, "You need to be on a release branch to prepare a release"
  project.prepare_release
  mesg project.message
end

#prepare_schema(name) ⇒ Object 



111
112
113
114
 
# File 'lib/prick/program.rb', line 111

def prepare_schema(name)
  project.prepare_schema(name)
  mesg project.message
end

#project ⇒ Object 



7
 
# File 'lib/prick/program.rb', line 7

def project() @project ||= Project.load end

#restore(file = nil) ⇒ Object 



221
222
223
224
 
# File 'lib/prick/program.rb', line 221

def restore(file = nil)
  file.nil? || File.exist?(file) or raise Error, "Can't find #{file}"
  project.restore(file)
end

#save(database, file) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/prick/program.rb', line 83

def save(database, file)
  file ||= "#{ENV['USER']}-#{name}-#{branch}.sql.gz"
  subject_mesg = database ? "database #{database}" : "current database"
  database = database ? Database.new(database, project.user) : project.database(version)
  project.save(file, database: database)
  mesg "Saved", subject_mesg, "to #{file}"
end

#upgrade ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/prick/program.rb', line 207

def upgrade
  # TODO: Shutdown connections
  project.database.version != project.version or raise Error, "Database already up to date"
  project.backup
  begin
    project.upgrade
  rescue RuntimeError
    project.restore
    raise Fail, "Failed upgrading database, rolled back to last version"
  end
end

#verb(*args) ⇒ Object 



18
 
# File 'lib/prick/program.rb', line 18

def verb(*args) puts args.compact.grep(/\S/).join(' ') if verbose end