Class: Boom::Command

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

Constant Summary

Constants included from Color

Boom::Color::CODES

Class Method Summary collapse

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.



268
269
270
271
272
273
 
# File 'lib/boom/command.rb', line 268

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.



75
76
77
78
79
80
81
82
 
# File 'lib/boom/command.rb', line 75

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

.copy(major, minor) ⇒ Object

Public: Copies to clipboard the Item’s value without printing to screen

Returns nothing



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

def copy(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
  Platform.copy(item)
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.



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

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.



87
88
89
90
91
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
 
# File 'lib/boom/command.rb', line 87

def delegate(command, major, minor)
  return all               if command == 'all'
  return edit              if command == 'edit'
  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 copy(major,minor) if command == 'copy' || command == 'c'
  return open(major,minor) if command == 'open' || command == 'o'
  return random(major)     if command == 'random' || command == 'rand' || command == 'r'

  if command == 'delete' || command == 'd'
    if minor
      return delete_item(major, minor)
    else
      return delete_list(major)
    end
  end

  # if we're operating on a List
  if storage.list_exists?(command)
    return detail_list(command) unless major
    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

  return search_items(command) if storage.item_exists?(command) and !major

  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.



285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/boom/command.rb', line 285

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.



242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/boom/command.rb', line 242

def delete_list(name)
  if storage.list_exists?(name)
    printf "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
  else
    output "We couldn't find that list."
  end
end

.detail_list(name) ⇒ Object

Public: prints all Items over a List.

name - the List object to iterate over

Returns nothing.



126
127
128
129
130
131
 
# File 'lib/boom/command.rb', line 126

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



182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/boom/command.rb', line 182

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.



348
349
350
 
# File 'lib/boom/command.rb', line 348

def edit
  output "#{cyan("Boom!")} #{Platform.edit(storage.json_file)}"
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.



27
28
29
30
31
32
33
34
 
# File 'lib/boom/command.rb', line 27

def execute(*args)
  command = args.shift
  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.



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
386
 
# File 'lib/boom/command.rb', line 355

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 <list>                   create a new list
    boom <list>                   show items for a list
    boom delete <list>            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 copy <name>              copy the item's value without echo
    boom copy <list> <name>       copy the item's value without echo
    boom delete <list> <name>     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.



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/boom/command.rb', line 136

def open(major, minor)
  if storage.list_exists?(major)
    list = List.find(major)
    if minor
      item = storage.items.detect { |item| item.name == minor }
      if item
        output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
      else
        output "Couldn't find #{yellow(minor)}."
      end
    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 }
    if item
      output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
    else
      output "Couldn't find #{yellow(major)}."
    end
  end
end

.output(s) ⇒ Object

Public: prints any given string.

s = String output

Prints to STDOUT and returns. This method exists to standardize output and for easy mocking or overriding.



42
43
44
 
# File 'lib/boom/command.rb', line 42

def output(s)
  puts(s)
end

.overview ⇒ Object

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

Returns nothing.



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/boom/command.rb', line 58

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.



163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/boom/command.rb', line 163

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.



334
335
336
 
# File 'lib/boom/command.rb', line 334

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.



305
306
307
308
309
310
311
 
# File 'lib/boom/command.rb', line 305

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.



320
321
322
323
324
325
326
327
328
329
 
# File 'lib/boom/command.rb', line 320

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

.stdin ⇒ Object

Public: gets $stdin.

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



50
51
52
 
# File 'lib/boom/command.rb', line 50

def stdin
  $stdin
end

.storage ⇒ Object

Public: accesses the in-memory JSON representation.

Returns a Storage instance.



19
20
21
 
# File 'lib/boom/command.rb', line 19

def storage
  Boom.storage
end

.version ⇒ Object

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

Returns a String identifying the version number.



341
342
343
 
# File 'lib/boom/command.rb', line 341

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