boom 0.0.1

data/License

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Zach Holman, http://zachholman.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,150 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/Readme.markdown

@@ -0,0 +1,116 @@
+# B O O M
+
+See? Look, a tiny explosion: \*
+
+## What's a boom?
+
+boom lets you access text snippets over your command line. I'm personally
+aiming for exactly two use cases, but I'm almost positive there are thirteen
+more. Here's a couple examples:
+
+- **Your own [del.icio.us](http://delicious.com)-esque URL tracker.** When I
+  make [clever animated
+  gifs](http://github.com/holman/dotfiles/blob/master/bin/gifme) of my
+  coworkers, I tend to lose the URL, which is a total bummer since I want to
+  repeatedly repost these images well past their funny expiration date. boom
+  lets me easily access the good stuff for years to come.
+- **Commonly-used email replies.** Everyone's got those stock replies in their
+  pocket for a few common use cases. Rather than keep some files strewn about
+  with the responses, boom gives me them on my ever-present command line.
+- **Simple todos.** You can super-quickly drop items into lists and remove them
+  when finished. I'm a big fan of simple, straightforward stuff. Plus, it's a
+  Dropbox away from simple cloud syncing. Someone get Cultured Code on the line
+  THIS MAY BE RELEVANT TO THEIR INTERESTS!
+
+We store everything in one JSON file in your home directory: `~/.boom`. The
+structure is simple, too. Each individual item is tossed on a `list`, and you
+can have multiple lists.
+
+## Show me the boom
+
+** Overview **
+
+    $ boom
+    gifs (5)
+    email (4)
+
+** Create a list **
+
+    $ boom urls
+    Boom! Created a new list called "urls".
+
+** Add an item **
+
+    # boom <list> <name> <value>
+    $ boom urls github https://github.com
+    Boom! "github" in "urls" is "https://github.com". Got it.
+
+** Copy an item's value to your clipboard **
+
+    $ boom github
+    Boom! Just copied https://github.com to your clipboard.
+
+    $ boom urls github
+    Boom! Just copied https://github.com to your clipboard.
+
+** List items in a list **
+
+    $ boom urls
+    blog   http://zachholman.com
+    github http://github.com
+
+** Delete a list **
+
+    $ boom urls delete
+    You sure you want to delete everything in "urls"? (y/n): y
+    Boom! Deleted all your urls.
+
+** Delete an item **
+
+    # boom urls github delete
+    Boom! "github" is gone forever.
+
+** List everything **
+
+    $ boom all
+      enemies
+        @kneath:          he's got dreamy eyes. he must die.
+        @rtomayko:        i must murder him for his mac and cheese recipe.
+        @luckiestmonkey:  she hates recycling.
+      urls
+        blog:   http://zachholman.com
+        github: https://github.com
+
+** It's just the command line, silly **
+
+So don't forget all your other favorites are there to help you, too:
+
+    $ boom all | grep @luckiestmonkey
+        @luckiestmonkey:  she hates recycling.
+
+## Install
+
+    gem install boom
+
+## Current Status
+
+Precarious. I'm starting to use this a bunch now, but if you're tossing in
+important business information (say, a carefully cultivated list of animated
+.gifs), you'd be sitting pretty if you made a backup of `~/.boom` every now and
+then, just in case. We're living on the edge, baby.
+
+Also, don't mistype anything. Everything should be 100% perfect if you type all
+the commands correctly. If you don't, it'll probably ungracefully error out and
+a puppy in Kansas will probably be murdered. You should be fine, though. As
+long as you don't have butter fingers.
+
+Soon enough, though, this'll be stable to the point where I can truthfully tell
+myself that this time baby, `boom` will be, bulletttttttttttttproof ♫.
+
+## I love you
+
+[Zach Holman](http://zachholman.com) made this. Ping me on Twitter —
+[@holman](http://twitter.com/holman) — if you're having issues, want me to
+merge in your pull request, or are using boom in a cool way. I'm kind of hoping
+this is generic enough that people do some fun things with it. First one to use
+`boom` to calculate their tax liability wins.

data/bin/boom

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'boom'
+
+storage = Boom::Storage.new
+Boom::Command.execute(storage,*ARGV)

data/boom.gemspec

@@ -0,0 +1,90 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'boom'
+  s.version           = '0.0.1'
+  s.date              = '2010-11-24'
+  s.rubyforge_project = 'boom'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "boom lets you access text snippets over your command line."
+  s.description = "God it's about every day where I think to myself, gadzooks,
+  I keep typing *REPETITIVE_BORING_TASK* over and over. Wouldn't it be great if
+  I had something like boom to store all these commonly-used text snippets for
+  me? Then I realized that was a worthless idea since boom hadn't been created
+  yet and I had no idea what that statement meant. At some point I found the
+  code for boom in a dark alleyway and released it under my own name because I
+  wanted to look smart."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Zach Holman"]
+  s.email    = 'github.com@zachholman.com'
+  s.homepage = 'https://github.com/holman/boom'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## This sections is only necessary if you have C extensions.
+  #s.require_paths << 'ext'
+  #s.extensions = %w[ext/extconf.rb]
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["boom"]
+  s.default_executable = 'boom'
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[Readme.markdown License]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('yajl-ruby', "~> 0.7.8")
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('mocha', "~> 0.9.9")
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    License
+    Rakefile
+    Readme.markdown
+    bin/boom
+    boom.gemspec
+    lib/boom.rb
+    lib/boom/clipboard.rb
+    lib/boom/command.rb
+    lib/boom/item.rb
+    lib/boom/list.rb
+    lib/boom/storage.rb
+    test/examples/urls.json
+    test/helper.rb
+    test/test_command.rb
+    test/test_item.rb
+    test/test_list.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
+end

data/lib/boom/clipboard.rb

@@ -0,0 +1,22 @@
+# Clipboard is a centralized point to shell out to each individual platform's
+# clipboard, pasteboard, or whatever they decide to call it.
+#
+module Boom
+  class Clipboard
+    class << self
+      
+      # Public: copies a given Item's value to the clipboard. This method is
+      # designed to handle multiple platforms.
+      #
+      # Returns nothing.
+      def copy(item)
+        if RUBY_PLATFORM =~ /darwin/
+          `echo '#{item.value}' | tr -d "\n" | pbcopy`
+        end
+
+        "Boom! We just copied #{item.value} to your clipboard."
+      end
+
+    end
+  end
+end

data/lib/boom/command.rb

@@ -0,0 +1,212 @@
+# Command is the main point of entry for boom commands; shell arguments are
+# passd through to Command, which then filters and parses through indivdual
+# commands and reroutes them to constituent object classes.
+#
+# Command also keeps track of one connection to Storage, which is how new data
+# changes are persisted to disk. It takes care of any data changes by calling
+# Boom::Command#save!.
+#
+module Boom
+  class Command
+    class << self
+
+      attr_accessor :storage
+
+      # Public: executes a command.
+      #
+      # storage - The Storage instance off which to run commands. This is
+      #           likely just Boom::Storage.new, since Boom::Storage should 
+      #           pick up the appropriate JSON file paths on its own.
+      # args    - The actual commands to operate on. Can be as few as zero
+      #           arguments or as many as three.
+      def execute(storage,*args)
+        @storage = storage
+
+        command = args[0]
+        major   = args[1]
+        minor   = args[2]
+
+        return overview unless command
+        delegate(command, major, minor)
+      end
+
+      # 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.
+      def output(s)
+        puts(s)
+      end
+
+      # Public: prints a tidy overview of your Lists in descending order of
+      # number of Items.
+      #
+      # Returns nothing.
+      def overview
+        storage.lists.each do |list|
+          output "  #{list.name} (#{list.items.size})"
+        end
+      end
+
+      # Public: prints the detailed view of all your Lists and all their
+      # Items.
+      #
+      # Returns nothing.
+      def all
+        storage.lists.each do |list|
+          output "  #{list.name}"
+          list.items.each do |item|
+            output "    #{item.name}: #{item.value}"
+          end
+        end
+      end
+
+      # Public: allows main access to most commands.
+      #
+      # Returns output based on method calls.
+      def delegate(command, major, minor)
+        return all if command == 'all'
+
+        # if we're operating on a List
+        if storage.list_exists?(command)
+          return list_delete(command) if major == 'delete'
+          return list_detail(command) unless major
+          unless minor == 'delete'
+            return add_item(command,major,minor) if minor
+            return search_list_for_item(command, major)
+          end
+        end
+
+        return search_items(command) if storage.item_exists?(command)
+
+        if minor == 'delete' and storage.item_exists?(major)
+          return item_delete(major)
+        end
+
+        return list_create(command)
+      end
+
+      # Public: prints all Items over a List.
+      #
+      # list - the List object to iterate over
+      #
+      # Returns nothing.
+      def list_detail(list_name)
+        list = storage.lists.first { |list| list.name == list_name } 
+        list.items.sort{ |x,y| x.name <=> y.name }.each do |item|
+          output "    #{item.name}: #{item.value}"
+        end
+      end
+
+      # Public: add a new List.
+      #
+      # name - the String name of the List.
+      #
+      # Example
+      #
+      #   Commands.list_create("snippets")
+      #
+      # Returns the newly created List.
+      def list_create(name)
+        lists = (storage.lists << List.new(name))
+        storage.lists = lists
+        output "Boom! Created a new list called \"#{name}\"."
+        save!
+      end
+
+      # Public: remove a named List.
+      #
+      # name - the String name of the List.
+      #
+      # Example
+      #
+      #   Commands.delete_list("snippets")
+      #
+      # Returns nothing.
+      def list_delete(name)
+        lists = storage.lists.reverse.reject { |list| list.name == name }
+        output "You sure you want to delete everything in \"#{name}\"? (y/n):"
+        if $stdin.gets.chomp == 'y'
+          storage.lists = lists
+          output "Boom! Deleted all your #{name}."
+          save!
+        else
+          output "Just kidding then."
+        end
+      end
+
+      # 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.
+      def add_item(list,name,value)
+        list = storage.lists.find{|storage_list| storage_list.name == list}
+        list.add_item(Item.new(name,value))
+        output "Boom! \"#{name}\" in \"#{list.name}\" is \"#{value}\". Got it."
+        save!
+      end
+
+      # Public: remove a named Item.
+      #
+      # name - the String name of the Item.
+      #
+      # Example
+      #
+      #   Commands.delete_item("an-item-name")
+      #
+      # Returns nothing.
+      def item_delete(name)
+        storage.lists = storage.lists.each do |list|
+          list.items.reject! { |item| item.name == name }
+        end
+        output "Boom! \"#{name}\" is gone forever."
+        save!
+      end
+
+      # 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.
+      def search_items(name)
+        item = storage.items.detect do |item|
+          item.name == name
+        end
+
+        output Clipboard.copy(item)
+      end
+
+      # Public: search for an Item in a particular list by name. Drops the 
+      # corresponding entry into your clipboard.
+      #
+      # 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.
+      def search_list_for_item(list_name, item_name)
+        list = storage.lists.first { |list| list.name == list_name }
+        item = list.items.first { |item| item.name == item_name }
+
+        output Clipboard.copy(item)
+      end
+
+      # Public: save in-memory data to disk.
+      #
+      # Returns whether or not data was saved.
+      def save!
+        storage.save!
+      end
+
+    end
+  end
+end

data/lib/boom/item.rb

@@ -0,0 +1,37 @@
+# The representation of the base unit in boom. An Item contains just a name and
+# a value. It doesn't know its parent relationship explicitly; the parent List
+# object instead knows which Items it contains.
+#
+module Boom
+  class Item
+    
+    # Public: the String name of the Item
+    attr_accessor :name
+
+    # Public: the String value of the Item
+    attr_accessor :value
+
+    # Public: creates a new Item object.
+    #
+    # name  - the String name of the Item
+    # value - the String value of the Item
+    #
+    # Examples
+    #
+    #   Item.new("github", "http://github.com")
+    #
+    # Returns the newly initialized Item.
+    def initialize(name,value)
+      @name = name
+      @value = value
+    end
+
+    # Public: creates a Hash for this Item.
+    #
+    # Returns a Hash of its data.
+    def to_hash
+      { @name => @value }
+    end
+
+  end
+end

data/lib/boom/list.rb

@@ -0,0 +1,44 @@
+# The List contains many Items. They exist as buckets in which to categorize
+# individual Items. The relationship is maintained in a simple array on the
+# List-level.
+#
+module Boom class List
+    
+    # Public: creates a new List instance in-memory.
+    #
+    # name - The name of the List. Fails if already used.
+    #
+    # Returns the unpersisted List instance.
+    def initialize(name)
+      @items = []
+      @name  = name
+    end
+
+    # Public: lets you access the array of items contained within this List.
+    #
+    # Returns an Array of Items.
+    attr_accessor :items
+
+    # Public: the name of the List.
+    #
+    # Returns the String name.
+    attr_accessor :name
+
+    # Public: associates an Item with this List.
+    #
+    # item - the Item object to associate with this List.
+    #
+    # Returns the current set of items.
+    def add_item(item)
+      @items << item
+    end
+
+    # Public: a Hash representation of this List.
+    #
+    # Returns a Hash of its own data and its child Items.
+    def to_hash
+      { name => items.collect(&:to_hash) }
+    end
+
+  end
+end

data/lib/boom/storage.rb

@@ -0,0 +1,125 @@
+# Storage is the middleman between changes the client makes in-memory and how
+# it's actually persisted to disk (and vice-versa). There are also a few
+# convenience methods to run searches and operations on the in-memory hash.
+#
+module Boom
+  class Storage
+    
+    JSON_FILE = "#{ENV['HOME']}/.boom"
+
+    # Public: the path to the JSON file used by boom.
+    #
+    # Returns the String path of boom's JSON representation.
+    def json_file
+      JSON_FILE
+    end
+
+    # Public: initializes a Storage instance by loading in your persisted data.
+    #
+    # Returns the Storage instance.
+    def initialize
+      @lists = []
+      explode_json(json_file)
+    end
+
+    # Public: the in-memory collection of all Lists attached to this Storage
+    # instance.
+    #
+    # lists - an Array of individual List items
+    #
+    # Returns nothing.
+    attr_writer :lists
+
+    # Public: the list of Lists in your JSON data, sorted by number of items
+    # descending.
+    #
+    # Returns an Array of List objects.
+    def lists
+      @lists.sort_by { |list| -list.items.size }
+    end
+
+    # Public: tests whether a named List exists.
+    #
+    # name - the String name of a List
+    #
+    # Returns true if found, false if not.
+    def list_exists?(name)
+      @lists.detect { |list| list.name == name }
+    end
+
+    # Public: all Items in storage.
+    #
+    # Returns an Array of all Items.
+    def items
+      @lists.collect(&:items).flatten
+    end
+
+    # Public: tests whether a named Item exists.
+    #
+    # name - the String name of an Item
+    #
+    # Returns true if found, false if not.
+    def item_exists?(name)
+      items.detect { |item| item.name == name }
+    end
+
+    # Public: persists your in-memory objects to disk in JSON format.
+    #
+    # Returns true if successful, false if unsuccessful.
+    def save!
+      File.open(json_file, 'w') {|f| f.write(to_json) }
+    end
+
+    # Public: the JSON representation of the current List and Item assortment
+    # attached to the Storage instance.
+    #
+    # Returns a String JSON representation of its Lists and their Items.
+    def to_json
+      Yajl::Encoder.encode(to_hash)
+    end
+
+    # Public: creates a Hash of the representation of the in-memory data
+    # structure. This percolates down to Items by calling to_hash on the List,
+    # which in tern calls to_hash on individual Items.
+    #
+    # Returns a Hash of the entire data set.
+    def to_hash
+      { :lists => lists.collect(&:to_hash) }
+    end
+
+
+  # INTERNAL METHODS ##########################################################
+
+    # Take a JSON representation of data and explode it out into the consituent
+    # Lists and Items for the given Storage instance.
+    #
+    # Returns nothing.
+    def explode_json(json)
+      bootstrap_json unless File.exist?(json)
+
+      storage = Yajl::Parser.new.parse(File.new(json, 'r'))
+      
+      storage['lists'].each do |lists|
+        lists.each do |list_name, items|
+          @lists << list = List.new(list_name)
+
+          items.each do |item|
+            item.each do |name,value|
+              list.add_item(Item.new(name,value))
+            end
+          end
+        end
+      end
+    end
+
+    # Takes care of bootstrapping the JSON file, both in terms of creating the
+    # file and in terms of creating a skeleton JSON schema.
+    #
+    # Return true if successfully saved.
+    def bootstrap_json
+      FileUtils.touch json_file
+      save!
+    end
+
+  end
+end

data/lib/boom.rb

@@ -0,0 +1,19 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'fileutils'
+require 'yajl'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'boom/clipboard'
+require 'boom/command'
+require 'boom/item'
+require 'boom/list'
+require 'boom/storage'
+
+module Boom
+  VERSION = '0.0.1'
+end

data/test/examples/urls.json

@@ -0,0 +1 @@
+{"lists":[{"urls":[{"github":"https://github.com"},{"blog":"http://zachholman.com"}]}]}

data/test/helper.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+
+begin
+  require 'rubygems'
+  require 'redgreen'
+rescue LoadError
+end
+
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'boom'
+
+# test/spec/mini 3
+# http://gist.github.com/25455
+# chris@ozmm.org
+# file:lib/test/spec/mini.rb
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+end

data/test/test_command.rb

@@ -0,0 +1,85 @@
+require 'helper'
+
+# Intercept STDOUT and collect it
+class Boom::Command
+
+  def self.capture_output
+    @output = ''
+  end
+
+  def self.captured_output
+    @output
+  end
+
+  def self.output(s)
+    @output << s
+  end
+
+  def self.save!
+    # no-op
+  end
+
+end
+
+class TestCommand < Test::Unit::TestCase
+
+  def setup
+    Boom::Storage.any_instance.stubs(:json_file).
+      returns('test/examples/urls.json')
+    @storage = Boom::Storage.new
+  end
+
+  def command(cmd)
+    cmd = cmd.split(' ') if cmd
+    Boom::Command.capture_output
+    Boom::Command.execute(@storage,*cmd)
+    Boom::Command.captured_output
+  end
+
+  def test_overview
+    assert_equal '  urls (2)', command(nil)
+  end
+
+  def test_list_detail
+    assert_match /github/, command('urls')
+  end
+
+  def test_list_all
+    cmd = command('all')
+    assert_match /urls/,    cmd
+    assert_match /github/,  cmd
+  end
+
+  def test_list_creation
+    assert_match /a new list called "newlist"/, command('newlist')
+  end
+
+  def test_item_access
+    assert_match /copied https:\/\/github\.com to your clipboard/,
+      command('github')
+  end
+
+  def test_item_access_scoped_by_list
+    assert_match /copied https:\/\/github\.com to your clipboard/,
+      command('urls github')
+  end
+
+  def test_item_creation
+    assert_match /"twitter" in "urls"/,
+      command('urls twitter http://twitter.com/holman')
+  end
+
+  def test_list_deletion_no
+    STDIN.stubs(:gets).returns('n')
+    assert_match /Just kidding then/, command('urls delete')
+  end
+
+  def test_list_deletion_yes
+    STDIN.stubs(:gets).returns('y')
+    assert_match /Deleted all your urls/, command('urls delete')
+  end
+
+  def test_item_deletion
+    assert_match /"github" is gone forever/, command('urls github delete')
+  end
+end

data/test/test_item.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestItem < Test::Unit::TestCase
+
+  def setup
+    @item = Boom::Item.new('github','https://github.com')
+  end
+
+  def test_name
+    assert_equal 'github', @item.name
+  end
+
+  def test_value
+    assert_equal 'https://github.com', @item.value
+  end
+
+  def test_to_hash
+    assert_equal 1, @item.to_hash.size
+  end
+
+end

data/test/test_list.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class TestList < Test::Unit::TestCase
+
+  def setup
+    @list = Boom::List.new('urls')
+    @item = Boom::Item.new('github','https://github.com')
+  end
+
+  def test_name
+    assert_equal 'urls', @list.name
+  end
+
+  def test_add_items
+    assert_equal 0, @list.items.size
+    @list.add_item(@item)
+    assert_equal 1, @list.items.size
+  end
+
+  def test_to_hash
+    assert_equal 0, @list.to_hash[@list.name].size
+    @list.add_item(@item)
+    assert_equal 1, @list.to_hash[@list.name].size
+  end
+
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: boom
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Zach Holman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-24 00:00:00 -08:00
+default_executable: boom
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 7
+        - 8
+        version: 0.7.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id002
+description: |-
+  God it's about every day where I think to myself, gadzooks,
+    I keep typing *REPETITIVE_BORING_TASK* over and over. Wouldn't it be great if
+    I had something like boom to store all these commonly-used text snippets for
+    me? Then I realized that was a worthless idea since boom hadn't been created
+    yet and I had no idea what that statement meant. At some point I found the
+    code for boom in a dark alleyway and released it under my own name because I
+    wanted to look smart.
+email: github.com@zachholman.com
+executables: 
+- boom
+extensions: []
+
+extra_rdoc_files: 
+- Readme.markdown
+- License
+files: 
+- License
+- Rakefile
+- Readme.markdown
+- bin/boom
+- boom.gemspec
+- lib/boom.rb
+- lib/boom/clipboard.rb
+- lib/boom/command.rb
+- lib/boom/item.rb
+- lib/boom/list.rb
+- lib/boom/storage.rb
+- test/examples/urls.json
+- test/helper.rb
+- test/test_command.rb
+- test/test_item.rb
+- test/test_list.rb
+has_rdoc: true
+homepage: https://github.com/holman/boom
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: boom
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: boom lets you access text snippets over your command line.
+test_files: 
+- test/test_command.rb
+- test/test_item.rb
+- test/test_list.rb