Class: Boom::Command

Inherits:
Object
  • Object
show all
Extended by:
Color, Output
Defined in:
lib/kaboom/command.rb

Constant Summary

Constants included from Color

Boom::Color::CODES

Class Method Summary collapse

Methods included from Output

output

Methods included from Color

colorize, included

Class Method Details

.add_item(list, name, value) ⇒ Object

Public: add a new Item to a list.

list - the String name of the List to associate with this Item name - the String name of the Item value - the String value of the Item

Example

Commands.add_item("snippets","sig","- @holman")

Returns the newly created Item.



263
264
265
266
267
268
 
# File 'lib/kaboom/command.rb', line 263

def add_item(list,name,value)
  list = List.find(list)
  list.add_item(Item.new(name,value))
  output "#{cyan("Boom!")} #{yellow(name)} in #{yellow(list.name)} is #{yellow(value)}. Got it."
  save
end

.all ⇒ Object

Public: prints the detailed view of all your Lists and all their Items.

Returns nothing.



80
81
82
83
84
85
86
87
 
# File 'lib/kaboom/command.rb', line 80

def all
  storage.lists.each do |list|
    output "  #{list.name}"
    list.items.each do |item|
      output "    #{item.short_name}:#{item.spacer} #{item.value}"
    end
  end
end

.check_if_remote(args) ⇒ Object 



39
40
41
42
43
44
45
46
47
 
# File 'lib/kaboom/command.rb', line 39

def check_if_remote args
  command = args.shift

  if command == "remote"
    Boom.use_remote
    command = args.shift
  end
  command
end

.create_list(name, item = nil, value = nil) ⇒ Object

Public: add a new List.

name - the String name of the List. item - the String name of the Item value - the String value of Item

Example

Commands.list_create("snippets")
Commands.list_create("hotness", "item", "value")

Returns the newly created List and creates an item when asked.



224
225
226
227
228
229
230
 
# File 'lib/kaboom/command.rb', line 224

def create_list(name, item = nil, value = nil)
  lists = (storage.lists << List.new(name))
  storage.lists = lists
  output "#{cyan("Boom!")} Created a new list called #{yellow(name)}."
  save
  add_item(name, item, value) unless value.nil?
end

.delegate(command, major, minor) ⇒ Object

Public: allows main access to most commands.

Returns output based on method calls.



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/kaboom/command.rb', line 92

def delegate(command, major, minor)
  return all               if command == 'all'
  return edit              if command == 'edit'
  return switch(major)     if command == 'switch'
  return show_storage      if command == 'storage'
  return version           if command == "-v"
  return version           if command == "--version"
  return help              if command == 'help'
  return help              if command[0] == 45 || command[0] == '-' # any - dash options are pleas for help
  return echo(major,minor) if command == 'echo' || command == 'e'
  return open(major,minor) if command == 'open' || command == 'o'
  return random(major)     if command == 'random' || command == 'rand' || command == 'r'

  # if we're operating on a List
  if storage.list_exists?(command)
    return delete_list(command) if major == 'delete'
    return detail_list(command) unless major
    unless minor == 'delete'
      return add_item(command,major,minor) if minor
      return add_item(command,major,stdin.read) if stdin.stat.size > 0
      return search_list_for_item(command, major)
    end
  end

  if minor == 'delete' and storage.item_exists?(major)
    return delete_item(command, major)
  end

  return search_items(command) if storage.item_exists?(command)

  return create_list(command, major, stdin.read) if !minor && stdin.stat.size > 0
  return create_list(command, major, minor)
end

.delete_item(list_name, name) ⇒ Object

Public: remove a named Item.

list_name - the String name of the List. name - the String name of the Item.

Example

Commands.delete_item("a-list-name", "an-item-name")

Returns nothing.



280
281
282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/kaboom/command.rb', line 280

def delete_item(list_name,name)
  if storage.list_exists?(list_name)
    list = List.find(list_name)
    if list.delete_item(name)
      output "#{cyan("Boom!")} #{yellow(name)} is gone forever."
      save
    else
      output "#{yellow(name)} #{red("not found in")} #{yellow(list_name)}"
    end
  else
    output "We couldn't find that list."
  end
end

.delete_list(name) ⇒ Object

Public: remove a named List.

name - the String name of the List.

Example

Commands.delete_list("snippets")

Returns nothing.



241
242
243
244
245
246
247
248
249
250
 
# File 'lib/kaboom/command.rb', line 241

def delete_list(name)
  output "You sure you want to delete everything in #{yellow(name)}? (y/n):"
  if $stdin.gets.chomp == 'y'
    List.delete(name)
    output "#{cyan("Boom!")} Deleted all your #{yellow(name)}."
    save
  else
    output "Just kidding then."
  end
end

.detail_list(name) ⇒ Object

Public: prints all Items over a List.

name - the List object to iterate over

Returns nothing.



150
151
152
153
154
155
 
# File 'lib/kaboom/command.rb', line 150

def detail_list(name)
  list = List.find(name)
  list.items.sort{ |x,y| x.name <=> y.name }.each do |item|
    output "    #{item.short_name}:#{item.spacer} #{item.value}"
  end
end

.echo(major, minor) ⇒ Object

Public: echoes only the Item’s value without copying

item_name - the String term to search for in all Item names

Returns nothing



198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/kaboom/command.rb', line 198

def echo(major, minor)
  unless minor
    item = storage.items.detect do |item|
      item.name == major
    end
    return output "#{yellow(major)} #{red("not found")}" unless item
  else
    list = List.find(major)
    item = list.find_item(minor)
    return output "#{yellow(minor)} #{red("not found in")} #{yellow(major)}" unless item
  end
  output item.value
end

.edit ⇒ Object

Public: launches JSON file in an editor for you to edit manually.

Returns nothing.



343
344
345
346
347
348
349
 
# File 'lib/kaboom/command.rb', line 343

def edit
  if storage.respond_to?("json_file")
    output "#{cyan("Boom!")} #{Platform.edit(storage.json_file)}"
  else
    output "This storage backend does not store #{cyan("Boom!")} data on your computer"
  end
end

.execute(*args) ⇒ Object

Public: executes a command.

args - The actual commands to operate on. Can be as few as zero

arguments or as many as three.



28
29
30
31
32
33
34
35
36
 
# File 'lib/kaboom/command.rb', line 28

def execute(*args)
  command = check_if_remote args

  major   = args.shift
  minor   = args.empty? ? nil : args.join(' ')

  return overview unless command
  delegate(command, major, minor)
end

.help ⇒ Object

Public: prints all the commands of boom.

Returns nothing.



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
 
# File 'lib/kaboom/command.rb', line 354

def help
  text = %{
    - boom: help ---------------------------------------------------

    boom                          display high-level overview
    boom all                      show all items in all lists
    boom edit                     edit the boom JSON file in $EDITOR
    boom help                     this help text
    boom storage                  shows which storage backend you're using
    boom switch <storage>         switches to a different storage backend

    boom <list>                   create a new list
    boom <list>                   show items for a list
    boom <list> delete            deletes a list

    boom <list> <name> <value>    create a new list item
    boom <name>                   copy item's value to clipboard
    boom <list> <name>            copy item's value to clipboard
    boom open <name>              open item's url in browser
    boom open <list> <name>       open all item's url in browser for a list
    boom random                   open a random item's url in browser
    boom random <list>            open a random item's url for a list in browser
    boom echo <name>              echo the item's value without copying
    boom echo <list> <name>       echo the item's value without copying
    boom <list> <name> delete     deletes an item

    all other documentation is located at:
      https://github.com/holman/boom
  }.gsub(/^ {8}/, '') # strip the first eight spaces of every line

  output text
end

.open(major, minor) ⇒ Object

Public: opens the Item.

Returns nothing.



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/kaboom/command.rb', line 160

def open(major, minor)
  if storage.list_exists?(major)
    list = List.find(major)
    if minor
      item = storage.items.detect { |item| item.name == minor }
      output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
    else
      list.items.each { |item| Platform.open(item) }
      output "#{cyan("Boom!")} We just opened all of #{yellow(major)} for you."
    end
  else
    item = storage.items.detect { |item| item.name == major }
    output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
  end
end

.overview ⇒ Object

Public: prints a tidy overview of your Lists in descending order of number of Items.

Returns nothing.



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

def overview
  storage.lists.each do |list|
    output "  #{list.name} (#{list.items.size})"
  end
  s =  "You don't have anything yet! To start out, create a new list:"
  s << "\n  $ boom <list-name>"
  s << "\nAnd then add something to your list!"
  s << "\n  $ boom <list-name> <item-name> <item-value>"
  s << "\nYou can then grab your new item:"
  s << "\n  $ boom <item-name>"
  output s if storage.lists.size == 0
end

.random(major) ⇒ Object

Public: Opens a random item

Returns nothing.



179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/kaboom/command.rb', line 179

def random(major)
  if major.nil?
    index = rand(storage.items.size)
    item = storage.items[index]
  elsif storage.list_exists?(major)
    list = List.find(major)
    index = rand(list.items.size)
    item = list.items[index]
  else
    output "We couldn't find that list."
  end
  open(item.name, nil) unless item.nil?
end

.save ⇒ Object

Public: save in-memory data to disk.

Returns whether or not data was saved.



329
330
331
 
# File 'lib/kaboom/command.rb', line 329

def save
  storage.save
end

.search_items(name) ⇒ Object

Public: search for an Item in all lists by name. Drops the corresponding entry into your clipboard.

name - the String term to search for in all Item names

Returns the matching Item.



300
301
302
303
304
305
306
 
# File 'lib/kaboom/command.rb', line 300

def search_items(name)
  item = storage.items.detect do |item|
    item.name == name
  end

  output "#{cyan("Boom!")} We just copied #{yellow(Platform.copy(item))} to your clipboard."
end

.search_list_for_item(list_name, item_name) ⇒ Object

Public: search for an Item in a particular list by name. Drops the corresponding entry into your clipboard if found.

list_name - the String name of the List in which to scope the search item_name - the String term to search for in all Item names

Returns the matching Item if found.



315
316
317
318
319
320
321
322
323
324
 
# File 'lib/kaboom/command.rb', line 315

def search_list_for_item(list_name, item_name)
  list = List.find(list_name)
  item = list.find_item(item_name)

  if item
    output "#{cyan("Boom!")} We just copied #{yellow(Platform.copy(item))} to your clipboard."
  else
    output "#{yellow(item_name)} #{red("not found in")} #{yellow(list_name)}"
  end
end

.show_storage ⇒ Object

Public: shows the current user’s storage.

Returns nothing.



129
130
131
 
# File 'lib/kaboom/command.rb', line 129

def show_storage
  output "You're currently using #{Boom.config.attributes['backend']}."
end

.stdin ⇒ Object

Public: gets $stdin.

Returns the $stdin object. This method exists to help with easy mocking or overriding.



55
56
57
 
# File 'lib/kaboom/command.rb', line 55

def stdin
  $stdin
end

.storage ⇒ Object

Public: accesses the in-memory JSON representation.

Returns a Storage instance.



20
21
22
 
# File 'lib/kaboom/command.rb', line 20

def storage
  Boom.storage
end

.switch(backend) ⇒ Object

Public: switch to a new backend.

backend - the String of the backend desired

Returns nothing.



138
139
140
141
142
143
 
# File 'lib/kaboom/command.rb', line 138

def switch(backend)
  Storage.backend = backend
  output "We've switched you over to #{backend}."
rescue NameError
  output "We couldn't find that storage engine. Check the name and try again."
end

.version ⇒ Object

Public: the version of boom that you’re currently running.

Returns a String identifying the version number.



336
337
338
 
# File 'lib/kaboom/command.rb', line 336

def version
  output "You're running boom #{Boom::VERSION}. Congratulations!"
end