Class: Raykit::Console

Inherits:
Object
  • Object
show all
Defined in:
lib/raykit/console.rb

Overview

The implementation for the raykit console application

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Console

Returns a new instance of Console.



9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/raykit/console.rb', line 9

def initialize
    @opts = Slop.parse do |o|
        o.string '-t','--task','rake task', default: 'default'
        o.bool '-v','--verbose','print detailed output', default: false
        o.bool '-q','--quit','quit on failure', default: true
    end

    if(opts.verbose?)
        puts "options: " + Rainbow(@opts.to_hash).yellow.bright
        puts "arguments:" + Rainbow(@opts.arguments).yellow.bright
    end
end

Instance Attribute Details

#opts ⇒ Object

Returns the value of attribute opts.



8
9
10
 
# File 'lib/raykit/console.rb', line 8

def opts
  @opts
end

Instance Method Details

#add ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/raykit/console.rb', line 87

def add
    if(@opts.arguments.length < 2)
        puts 'add requires a url'
        return 1
    end
    url=@opts.arguments[1] 
    if(REPOSITORIES.include?(url))
        puts 'url ' + url + ' already exists.'
    else
        REPOSITORIES << url
        REPOSITORIES.save(REPOSITORIES.filename)
        puts 'url ' + url + ' added.'
    end
end

#clean ⇒ Object 



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/raykit/console.rb', line 225

def clean
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    REPOSITORIES.matches(pattern).each{|url|
        repo=Raykit::Git::Repository.new(url)
        work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
        if(Dir.exist?(work.directory))
            puts 'removing ' + work.directory
            begin
                FileUtils.rm_rf(work.directory,secure:true)
            rescue
                puts 'error removing ' + work.directory
            end
        end
    }
end

#copy ⇒ Object 



254
255
256
257
258
259
260
261
262
263
 
# File 'lib/raykit/console.rb', line 254

def copy
    if(@opts.arguments.length < 3)
        puts 'source and destination arguments are required for copy'
        return 1
    end
    source = @opts.arguments[1]
    dest = @opts.arguments[2]
    FileUtils.cp(source,dest)
    puts "copied #{source} to #{dest}"
end

#import ⇒ Object 



215
216
217
218
219
220
221
222
223
 
# File 'lib/raykit/console.rb', line 215

def import
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    puts 'scanning...'
    count=REPOSITORIES.length
    REPOSITORIES.import(pattern)
    new_count=REPOSITORIES.length-count
    puts "imported #{new_count} git repositories"
end

#pull ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/raykit/console.rb', line 180

def pull
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    REPOSITORIES.matches(pattern).each{|url|
        begin
            repo=Raykit::Git::Repository.new(url)
            work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
            if(Dir.exist?(work.directory) && !work.directory=='.git')
                Dir.chdir(work.directory) do
                    diff=`git diff`.strip
                    status=`git status`.strip
                    if(diff.length == 0 && status.include?('nothing to commit'))
                        cmd = Command.new('git pull')
                        cmd.summary if(@opts.verbose?)

                        if(cmd.exitstatus != 0)
                            cmd.details
                            if(@opts.quit?)
                                abort Rainbow(cmd.summary).blue.bright
                            end
                        end
                    end
                end
            end
        rescue => error
            issue = 'error occurred for pull of ' + url +' ' + error.to_s
            if(@opts.quit?)
                abort Rainbow(issue).blue.bright
            else
                puts Rainbow(issue).blue.bright
            end
        end
    }
end

#rake(hash) ⇒ Object 



265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/raykit/console.rb', line 265

def rake(hash)
    REPOSITORIES.each{|remote|
        if(remote.include?(hash[:pattern]))
            begin
                puts "remote: #{remote}"
                cmd = Raykit::Rake::run(remote,'master')
                elapsed_str = Timer.get_elapsed_str(cmd.elapsed)
                if(cmd.exitstatus == 0)
                    puts elapsed_str + " " +  Rainbow(SECRETS.hide(cmd.command)).yellow.bright + " (#{cmd.directory})"
                else
                    puts "\r\n" + cmd.command + "\r\n"
                    puts "\r\n" + cmd.output + "\r\n"
                    puts "\r\n" + cmd.error + "\r\n"
                    puts ''
                    puts Rainbow(elapsed_str).red.bright + " " +  Rainbow(cmd.command).white
                end
            rescue
                puts 'rescued...'
            end
        end
    }
end

#remove ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/raykit/console.rb', line 102

def remove
    if(@opts.arguments.length < 2)
        puts 'remove requires a url or pattern'
        return 1
    end
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    remove_urls = REPOSITORIES.matches(pattern)
    if(remove_urls.length == 0)
        puts 'no matching urls found.'
    
    else
        remove_urls.each{|url|
        REPOSITORIES.delete(url)
        puts 'url ' + url + ' removed.'
        }
        REPOSITORIES.save(REPOSITORIES.filename)
    end
end

#run ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/raykit/console.rb', line 22

def run
    verb = "usage"
    verb = @opts.arguments[0] if(@opts.arguments.length > 0)
    case verb
    when "usage"
        usage
    when "add"
        add
    when "remove"
        remove
    when "show"
        show
    when "work"
        work
    when "import"
        import
    when "clean"
        clean
    when "sync_version"
        sync_version
    when "copy"
        copy
    when "pull"
        pull
    else
        puts 'unrecognized command ' + verb
        return 1
    end
end

#show ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/raykit/console.rb', line 122

def show
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    REPOSITORIES.matches(pattern).each{|url|
        puts url
    }
end

#sync_version ⇒ Object 



242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/raykit/console.rb', line 242

def sync_version
    if(@opts.arguments.length < 3)
        puts 'source and destination arguments are required for sync_version'
        return 1
    end
    source = @opts.arguments[1]
    dest = @opts.arguments[2]
    Raykit::Version::sync_file_versions(source,dest)
    version = Raykit::Version::detect(source,false)
    puts "version #{version} detected in #{source}, updating #{dest} to match."
end

#usage ⇒ Object 



76
77
78
79
80
81
82
83
84
85
 
# File 'lib/raykit/console.rb', line 76

def usage

    puts "Usage: raykit VERB [GIT_URL|PATTERN] [OPTIONS]"
    verb_descriptions.each{|k,v|
        puts k.ljust(15,' ') + " - " + v
    }
    #puts @opts
    #puts "verbs: " + verbs.to_s
    0
end

#verb_descriptions ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/raykit/console.rb', line 52

def verb_descriptions
    { "add"=> "add a git url",
    "remove" => "remove one or more git urls",
    "show" => "show git urls matching a specific pattern",
    "work" => "clone and rake a git repository",
    "import" => "import git urls matching a specific pattern",
    "clean" => "clean one or more working directories",
    "pull" => "preform git pull on one or more working directories",
    "sync_version" => "synchronize the version number between two files",
    "copy" => "copy a file"
}
end

#verb_usage ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/raykit/console.rb', line 64

def verb_usage
    { "add" => "add GIT_URL",
        "remove" => "remove URL_PATTERN",
        "show" => "show URL_PATTERN",
        "work" => "work URL_PATTERN [--task RAKE_TASK]",
        "import" => "import URL_PATTERN",
        "clean" => "clean URL_PATTERN",
        "pull" => "pull URL_PATTERN",
        "sync_version" => "sync_version SOURCE_FILENAME DESTINATION_FILENAME",
        "copy" => "copy SOURCE DESTINATION"}
end

#work ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/raykit/console.rb', line 130

def work
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)

    work_repositories = REPOSITORIES.matches(pattern)
    errors=Array.new()
    puts 'work: found ' + work_repositories.length.to_s + ' matching urls'
    work_repositories.each{|url|
        exitstatus = work_url(url)
        puts ' ' if(@opts.verbose?)
        return exitstatus if(@opts[:quit] && exitstatus != 0)
    }
    0
end

#work_url(url) ⇒ Object 



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/raykit/console.rb', line 145

def work_url(url)
    puts Rainbow(url).yellow.bright
    repo=Raykit::Git::Repository.new(url)
    work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
    if(!Dir.exist?(work.directory))
        clone = Command.new("git clone #{url} #{work.directory}")
        puts clone.summary if(@opts.verbose?)
        if(clone.exitstatus != 0)
            clone.details
            return clone.exitstatus
        end
    end
    if(Dir.exist?(work.directory))
        Dir.chdir(work.directory) do
            if(File.exist?('rakefile.rb'))
                rake = Raykit::Command.new("rake #{@opts[:task]}")
                #if(rake.exitstatus != 0)
                #    rake.summary true
                #end
                rake.summary(true) if(@opts.verbose?) || rake.exitstatus != 0
                if(rake.exitstatus != 0)
                    #puts 'rake exitstatus = ' + rake.exitstatus.to_s
                    rake.details
                    rake.summary true
                    return rake.exitstatus
                end
            else
                puts('rakefile.rb not found in ' + work.directory)
                return 1
            end
        end
    end
    return 0
end