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(@otps.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 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/raykit/console.rb', line 204

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 



233
234
235
236
237
238
239
240
241
242
 
# File 'lib/raykit/console.rb', line 233

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 



194
195
196
197
198
199
200
201
202
 
# File 'lib/raykit/console.rb', line 194

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 



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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/raykit/console.rb', line 150

def pull
    pattern=''
    pattern=@opts.arguments[1] if(@opts.arguments.length > 1)
    REPOSITORIES.matches(pattern).each{|url|
        begin
            puts '.'
            repo=Raykit::Git::Repository.new(url)
            work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
            if(Dir.exist?(work.directory))
                git_dir = work.directory + '/.git'
                if(!Directory.exist?(git_dir))
                    issue = work.directory + ' is not a git directory';
                    if(@opts.quit?)
                        abort Rainbow(issue).blue.bright
                    else
                        puts Rainbow(issue).blue.bright
                    end
                else
                    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)
                                puts Rainbow('error occurred for pull of ' + url).blue
                                puts cmd.output
                                puts cmd.error
                                puts
                                if(@opts.quit?)
                                    abort Rainbow(elapsed_str).red.bright + " " +  Rainbow(cmd.command).white
                                end
                            end
                        end
                    end
                end
            end
        rescue => error
            puts 'error occurred for pull of ' + url + error
        end
    }
end

#rake(hash) ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/raykit/console.rb', line 244

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 



221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/raykit/console.rb', line 221

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

def work
    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))
            PROJECT.run("git clone #{url} #{work.directory}")
        end
        if(Dir.exist?(work.directory))
            puts work.directory
            begin
            work.rake(@opts[:task])
            rescue
                puts 'error occurred with rake in ' + work.directory
            end
        end
    }
end