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
21
 
# 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','--quiet','minimal output', default: false
        o.bool '-s','--stop','stop on error', 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 



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

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 



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

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

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



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

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 



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

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 



178
179
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
 
# File 'lib/raykit/console.rb', line 178

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 



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

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 



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

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 



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
51
 
# File 'lib/raykit/console.rb', line 23

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 



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

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

#usage ⇒ Object 



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

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 



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

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 



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

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 



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

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[:stop] && exitstatus != 0)
    }
    0
end

#work_url(url) ⇒ Object 



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
 
# File 'lib/raykit/console.rb', line 146

def work_url(url)
    return 0 if(url == "https://gitlab.com/lou-parslow/raykit.git")
    puts Rainbow(url).yellow.bright if(@opts.verbose?)
    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} --recursive")
        puts clone.summary if(!@opts.quiet?)
        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]}")
                rake.summary(true) if(!@opts.quiet?) || rake.exitstatus != 0
                if(rake.exitstatus != 0)
                    rake.details
                    rake.summary true
                    return rake.exitstatus
                end
            else
                puts('rakefile.rb not found in ' + work.directory) if(@opts.verbose?)
                return 0
            end
        end
    end
    return 0
end