boom 0.0.10 → 0.1.0

data/CHANGELOG.markdown

@@ -1,6 +1,11 @@
 # boom changes
 
-## head
+## 0.1.0
+- boom has been rewritten to use multiple backends. Use `boom switch <backend>`
+  to switch from the default JSON backend. Currently only Redis is supported.
+  Pull Requests are welcome.
+
+## 0.0.10
 - `boom open` will open the Item's URL in a browser, or it'll open all the URLs
   in a List for you. Thanks [lwe](https://github.com/lwe).
 - Values for item creation can have spaces, and then they get concat'ed as one
@@ -10,6 +15,8 @@
 - Also started `completion/`, a place to drop in scripts to set up completion
   support for boom. Starting out with [thbishop](https://github.com/thbishop)'s
   bash script, but if anyone has something for zsh I'd kiss them a bit.
+- `boom echo` (and `boom e`) just echos the value; great for command-line
+  scripts and junk! Thanks [bschaeffer](https://github.com/bschaeffer).
 
 ## 0.0.9
 - Backport `Symbol#to_proc` for 1.8.6 support (thanks 

data/README.markdown

@@ -1,138 +1,18 @@
 # B O O M
 
-See? Look, a tiny explosion: \*
+## About
 
-## What's a boom?
+boom manages your text snippets. On the command line. I just blew your mind.
 
-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
-
-** Open in browser **
-
-    $ boom open facebook-stalking
-    Boom! We just opened all of "shoes" for you.
-
-In other words, this will open all the links in `facebook-stalking` in your
-browser. You creep. You can also just open up one:
-
-    $ boom open twitter
-    Boom! We just opened http://twitter.com for you.
-
-** Echo an item**
-
-	# boom echo <list> <name>
-	# boom echo <name>
-	$ git clone $(boom echo github)holman/boom
-	Cloning into boom...
-
-Impossible... no. It's silly, but not impossible. 
-
-** Help **
-
-    $ boom help
-
-** Manual edit **
-
-If you want to edit the underlying JSON directly, make sure your `$EDITOR`
-environment variable is set, and run:
-
-    $ boom edit
-
-** 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.
+For more details about what boom is and how it works, check out
+[boom's website](http://holman.github.com/boom). For full usage details
+(including a complete list of commands), check out
+[boom's wiki](https://github.com/holman/boom/wiki).
 
 ## 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.
-
-Soon enough, though, this'll be stable to the point where I can truthfully tell
-myself that this time baby, `boom` will be, bulletttttttttttttproof ♫.
-
 ## Contribute
 
 I'd love to include your contributions, friend. Make sure your methods are

data/boom.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## 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.10'
-  s.date              = '2011-01-26'
+  s.version           = '0.1.0'
+  s.date              = '2011-02-28'
   s.rubyforge_project = 'boom'
 
   ## Make sure your summary is short. The description may be as long
@@ -75,14 +75,22 @@ Gem::Specification.new do |s|
     completion/boom.zsh
     lib/boom.rb
     lib/boom/command.rb
+    lib/boom/config.rb
     lib/boom/core_ext/symbol.rb
     lib/boom/item.rb
     lib/boom/list.rb
     lib/boom/platform.rb
     lib/boom/storage.rb
+    lib/boom/storage/base.rb
+    lib/boom/storage/json.rb
+    lib/boom/storage/mongodb.rb
+    lib/boom/storage/redis.rb
+    test/examples/config_json.json
+    test/examples/test_json.json
     test/examples/urls.json
     test/helper.rb
     test/test_command.rb
+    test/test_config.rb
     test/test_item.rb
     test/test_list.rb
   ]

data/lib/boom/command.rb

@@ -6,7 +6,7 @@
 #
 # 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!.
+# Boom::Command#save.
 #
 module Boom
   class Command
@@ -50,6 +50,13 @@ module Boom
         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
 
       # Public: prints the detailed view of all your Lists and all their
@@ -71,10 +78,12 @@ module Boom
       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 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'
+        return open(major,minor) if command == 'open' || command == 'o'
 
         # if we're operating on a List
         if storage.list_exists?(command)
@@ -95,6 +104,25 @@ module Boom
         return create_list(command)
       end
 
+      # Public: shows the current user's storage.
+      #
+      # Returns nothing.
+      def show_storage
+        output "You're currently using #{Boom.config.attributes['backend']}."
+      end
+
+      # Public: switch to a new backend.
+      #
+      # backend - the String of the backend desired
+      #
+      # Returns nothing.
+      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
+
       # Public: prints all Items over a List.
       #
       # name - the List object to iterate over
@@ -153,7 +181,7 @@ module Boom
         lists = (storage.lists << List.new(name))
         storage.lists = lists
         output "Boom! Created a new list called \"#{name}\"."
-        save!
+        save
       end
 
       # Public: remove a named List.
@@ -170,7 +198,7 @@ module Boom
         if $stdin.gets.chomp == 'y'
           List.delete(name)
           output "Boom! Deleted all your #{name}."
-          save!
+          save
         else
           output "Just kidding then."
         end
@@ -191,7 +219,7 @@ module Boom
         list = List.find(list)
         list.add_item(Item.new(name,value))
         output "Boom! \"#{name}\" in \"#{list.name}\" is \"#{value}\". Got it."
-        save!
+        save
       end
 
       # Public: remove a named Item.
@@ -208,7 +236,7 @@ module Boom
         list = List.find(list_name)
         list.delete_item(name)
         output "Boom! \"#{name}\" is gone forever."
-        save!
+        save
       end
 
       # Public: search for an Item in all lists by name. Drops the 
@@ -246,8 +274,8 @@ module Boom
       # Public: save in-memory data to disk.
       #
       # Returns whether or not data was saved.
-      def save!
-        storage.save!
+      def save
+        storage.save
       end
 
       # Public: launches JSON file in an editor for you to edit manually. Uses
@@ -270,6 +298,8 @@ module Boom
           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

data/lib/boom/config.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+#
+# Config manages all the config information for boom and its backends. It's a
+# simple JSON Hash that gets persisted to `~/.boom` on-disk. You may access it
+# as a Hash:
+#
+#     config.attributes = { :backend => "JSON" }
+#     config.attributes[:backend]
+#     # => "json"
+#
+#     config.attributes[:backend] = "Redis"
+#     config.attributes[:backend]
+#     # => "redis"
+#
+module Boom
+  class Config
+
+    # The main config file for boom
+    FILE = "#{ENV['HOME']}/.boom.conf"
+
+    # Public: The attributes Hash for configuration options. The attributes
+    # needed are dictated by each backend, but the `backend` option must be
+    # present.
+    attr_reader :attributes
+
+    # Public: creates a new instance of Config.
+    #
+    # This will load the attributes from boom's config file, or bootstrap it
+    # if this is a new install. Bootstrapping defaults to the JSON backend.
+    #
+    # Returns nothing.
+    def initialize
+      bootstrap unless File.exist?(file)
+      load_attributes
+    end
+
+    # Public: accessor for the configuration file.
+    #
+    # Returns the String file path.
+    def file
+      FILE
+    end
+
+    # Public: saves an empty, barebones hash to @attributes for the purpose of
+    # new user setup.
+    #
+    # Returns whether the attributes were saved.
+    def bootstrap
+      @attributes = {
+        :backend => 'JSON'
+      }
+      save
+    end
+
+    # Public: assigns a hash to the configuration attributes object. The
+    # contents of the attributes hash depends on what the backend needs. A
+    # `backend` key MUST be present, however.
+    #
+    # attrs - the Hash representation of attributes to persist to disk.
+    #
+    # Examples
+    #
+    #     config.attributes = {"backend" => "json"}
+    #
+    # Returns whether the attributes were saved.
+    def attributes=(attrs)
+      @attributes = attrs
+      save
+    end
+
+    # Public: loads and parses the JSON tree from disk into memory and stores
+    # it in the attributes Hash.
+    #
+    # Returns nothing.
+    def load_attributes
+      @attributes = Yajl::Parser.new.parse(File.new(file, 'r'))
+    end
+
+    # Public: writes the in-memory JSON Hash to disk.
+    #
+    # Returns nothing.
+    def save
+      json = Yajl::Encoder.encode(attributes, :pretty => true)
+      File.open(file, 'w') {|f| f.write(json) }
+    end
+
+  end
+end

data/lib/boom/storage/base.rb

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+# 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
+  module Storage
+    class Base
+
+      # Public: initializes a Storage instance by loading in your persisted data from adapter.
+      #
+      # Returns the Storage instance.
+      def initialize
+        @lists = []
+        bootstrap
+        populate
+      end
+
+      # run bootstrap tasks for the storage
+      def bootstrap ; end
+
+      # populate the in-memory store with all the lists and items
+      def populate ; end
+
+      # save the data
+      def save ; 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: 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
+
+    end
+  end
+end

data/lib/boom/storage/json.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+#
+# Json is the default storage option for boom. It writes a Json file to
+# ~/.boom. Pretty neat, huh?
+#
+module Boom
+  module Storage
+    class Json < Base
+    
+      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
+
+      # 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
+        return if File.exist?(json_file)
+        FileUtils.touch json_file
+        File.open(json_file, 'w') {|f| f.write(to_json) }
+        save
+      end
+
+      # Take a Json representation of data and explode it out into the consituent
+      # Lists and Items for the given Storage instance.
+      #
+      # Returns nothing.
+      def populate
+        storage = Yajl::Parser.new.parse(File.new(json_file, '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
+
+      # Public: persists your in-memory objects to disk in Json format.
+      #
+      # lists_Json - list 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, :pretty => true)
+      end
+
+    end
+  end
+end

data/lib/boom/storage/mongodb.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+# Storage adapter that saves data from boom to MongoDB instead of JSON file.
+#
+# This was grabbed from antonlindstrom's fork, but he wrote it before the 0.1.0
+# changes to boom. It would need to be updated to use Boom::Config and to
+# inherit methods from Boom::Storage::Base. Until then, this is chillin' here
+# until it gets fixed.
+
+module Boom
+  module Storage
+    class MongoDB
+      
+      MONGO_CFG = "#{ENV['HOME']}/.boomdb.conf"
+
+      # Public: the path to the JSON Mongo config file, userdata.
+      #
+      # Returns the String path of boom's MongoDB userdata
+      def mongo_cfg
+        MONGO_CFG
+      end
+
+      # Public: initializes a Storage instance by loading in your persisted data.
+      #
+      # Returns the Storage instance.
+      def initialize
+        require 'mongo'
+        
+        @lists = []
+        @mongo_coll = nil
+        mongo_initialize(mongo_cfg) # Initialize the MongoDB and set data in memory
+        collect
+      end
+
+      # Public: return the list from mongodb
+      #
+      # Returns list
+      def lists
+        @lists
+      end
+
+      # Public: Save to MongoDB
+      #
+      # lists_json - the list to be saved in JSON format
+      #
+      # Returns whatever mongo returns.
+      def save(lists_json)
+        doc = @mongo_coll.find_one()
+        @mongo_coll.update({"_id" => doc["_id"]}, {'boom' => lists_json})
+      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 collect
+
+        s = @mongo_coll.find_one['boom']
+        storage = Yajl::Parser.new.parse(s)
+
+        return if storage['lists'].nil?
+
+        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
+
+    ##### MONGODB ######
+
+      # Initialize MongoDB and set data in memory
+      #
+      # config_file - The MongoDB config_file path defined
+      #
+      # Returns database obj.
+      def mongo_initialize(config_file)
+        bootstrap_config(config_file) unless File.exists?(config_file)
+        config = parse_mongo_cfg(config_file)
+
+        db = Mongo::Connection.new(config['host'], config['port']).db(config['database'])
+        auth = db.authenticate(config['username'], config['password'])
+
+        # Get collection collection;
+        @mongo_coll = db.collection(config['collection'])
+
+        @mongo_coll.insert("boom" => '{"lists": [{}]}') if @mongo_coll.find_one.nil?
+
+        return @mongo_coll
+      end
+
+      # Parse Mongo JSON Config
+      #
+      # config_file - The MongoDB config_file path defined
+      #
+      # Returns a hash of Mongo Userdata
+      def parse_mongo_cfg(config_file)
+
+        mongod = Hash.new
+        config = Yajl::Parser.new.parse(File.open(config_file, 'r'))
+
+        config.each_pair do |type, data|
+          mongod[type] = data
+        end
+        return mongod
+      end
+
+      # Run a default config
+      #
+      # config_file - The MongoDB config_file path defined
+      #
+      # Returns File obj.
+      def bootstrap_config(config_file)
+        config = Hash.new
+
+        config['host'] = 'localhost'
+        config['port'] = '27017'
+        config['database'] = 'boom'
+        config['username'] = 'boom'
+        config['password'] = 's3cr3t'
+        config['collection'] = 'boom'
+
+        # Write to CFG
+        json_cfg =  Yajl::Encoder.encode(config, :pretty => true)
+        File.open(config_file, 'w') {|f| f.write(json_cfg) }
+      end
+
+
+    end
+  end
+end

data/lib/boom/storage/redis.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+#
+# Sup, Redis.
+#
+require 'digest'
+require 'redis'
+
+module Boom
+  module Storage
+    class Redis < Base
+
+      def redis
+        @redis ||= ::Redis.new :host => Boom.config.attributes["redis"]["host"],
+                               :port => Boom.config.attributes["redis"]["port"]
+      end
+
+      def bootstrap
+      end
+
+      def populate
+        lists = redis.smembers("boom:lists") || []
+
+        lists.each do |sha|
+          list_name  = redis.get("boom:lists:#{sha}:name")
+          @lists << list = List.new(list_name)
+
+          shas = redis.lrange("boom:lists:#{sha}:items",0,-1) || []
+
+          shas.each do |item_sha|
+            name  = redis.get "boom:items:#{item_sha}:name"
+            value = redis.get "boom:items:#{item_sha}:value"
+            list.add_item(Item.new(name, value))
+          end
+        end
+      end
+
+      def clear
+        redis.del "boom:lists"
+        redis.del "boom:items"
+      end
+
+      def save
+        clear
+
+        lists.each do |list|
+          list_sha = Digest::SHA1.hexdigest(list.name)
+          redis.set   "boom:lists:#{list_sha}:name", list.name
+          redis.sadd  "boom:lists", list_sha
+
+          list.items.each do |item|
+            item_sha = Digest::SHA1.hexdigest(item.name)
+            redis.rpush "boom:lists:#{list_sha}:items", item_sha
+            redis.set   "boom:items:#{item_sha}:name", item.name
+            redis.set   "boom:items:#{item_sha}:value", item.value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/boom/storage.rb

@@ -1,126 +1,21 @@
 # coding: utf-8
 
-# 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.
+#
+# Storage is the interface between multiple Backends. You can use Storage
+# directly without having to worry about which Backend is in use.
 #
 module Boom
-  class Storage
+  module 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, :pretty => true)
-    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
+    def self.backend=(backend)
+      backend = backend.capitalize
+      Boom::Storage.const_get(backend)
+      Boom.config.attributes['backend'] = backend.downcase
+      Boom.config.save
     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!
+    def self.backend
+      Boom::Storage.const_get(Boom.config.attributes['backend'].capitalize).new
     end
 
   end

data/lib/boom.rb

@@ -12,16 +12,29 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 
 require 'boom/platform'
 require 'boom/command'
+require 'boom/config'
 require 'boom/item'
 require 'boom/list'
+
 require 'boom/storage'
+require 'boom/storage/base'
+require 'boom/storage/json'
+require 'boom/storage/redis'
+require 'boom/storage/mongodb'
 
 require 'boom/core_ext/symbol'
 
 module Boom
-  VERSION = '0.0.10'
+  VERSION = '0.1.0'
+
+  extend self
 
-  def self.storage
-    @storage ||= Boom::Storage.new
+  def storage
+    @storage ||= Boom::Storage.backend
   end
+
+  def config
+    @config ||= Boom::Config.new
+  end
+
 end

data/test/examples/config_json.json

@@ -0,0 +1,3 @@
+{
+  backend: 'Json'
+}

data/test/examples/test_json.json

@@ -0,0 +1,3 @@
+{
+  "backend": "Json"
+}

data/test/helper.rb

@@ -16,7 +16,9 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'boom'
 
 def boom_json(name)
-  Boom::Storage.any_instance.stubs(:json_file).
-    returns("test/examples/#{name}.json")
-  Boom.stubs(:storage).returns(Boom::Storage.new)
+  root = File.expand_path(File.dirname(__FILE__))
+  Boom::Storage::Json.any_instance.stubs(:save).returns(true)
+  Boom::Storage::Json.any_instance.stubs(:json_file).
+    returns("#{root}/examples/#{name}.json")
+  Boom.stubs(:storage).returns(Boom::Storage::Json.new)
 end

data/test/test_command.rb

@@ -36,6 +36,13 @@ class TestCommand < Test::Unit::TestCase
     Boom::Command.captured_output
   end
 
+  def test_overview_for_empty
+    storage = Boom::Storage
+    storage.stubs(:lists).returns([])
+    Boom::Command.stubs(:storage).returns(storage)
+    assert_match /have anything yet!/, command(nil)
+  end
+
   def test_overview
     assert_equal '  urls (2)', command(nil)
   end
@@ -139,4 +146,19 @@ class TestCommand < Test::Unit::TestCase
   def test_echo_list_item_does_not_exist
     assert_match /"wrong" not found in "urls"/, command('echo urls wrong')
   end
+
+  def test_show_storage
+    assert_match /You're currently using json/, command('storage')
+  end
+  
+  def test_nonexistant_storage_switch
+    Boom::Config.any_instance.stubs(:save).returns(true)
+    assert_match /couldn't find that storage engine/, command('switch dkdkdk')
+  end
+
+  def test_storage_switch
+    Boom::Config.any_instance.stubs(:save).returns(true)
+    assert_match /We've switched you over to redis/, command('switch redis')
+  end
+
 end

data/test/test_config.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'helper'
+
+class TestConfig < Test::Unit::TestCase
+
+  def setup
+    Boom::Config.any_instance.stubs(:file).
+      returns("test/examples/test_json.json")
+
+    @config = Boom::Config.new
+    @config.stubs(:save).returns(true)
+  end
+
+  def test_bootstraps_config
+    @config.bootstrap
+    assert_equal ({:backend => 'JSON'}), @config.attributes
+  end
+
+  def test_attributes
+    @config.attributes[:wu_tang] = 'clan'
+    assert_equal 'clan', @config.attributes[:wu_tang]
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: boom
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 10
-  version: 0.0.10
+  version: 0.1.0
 platform: ruby
 authors: 
 - Zach Holman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-26 00:00:00 -08:00
+date: 2011-02-28 00:00:00 -08:00
 default_executable: boom
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,14 +77,22 @@ files:
 - completion/boom.zsh
 - lib/boom.rb
 - lib/boom/command.rb
+- lib/boom/config.rb
 - lib/boom/core_ext/symbol.rb
 - lib/boom/item.rb
 - lib/boom/list.rb
 - lib/boom/platform.rb
 - lib/boom/storage.rb
+- lib/boom/storage/base.rb
+- lib/boom/storage/json.rb
+- lib/boom/storage/mongodb.rb
+- lib/boom/storage/redis.rb
+- test/examples/config_json.json
+- test/examples/test_json.json
 - test/examples/urls.json
 - test/helper.rb
 - test/test_command.rb
+- test/test_config.rb
 - test/test_item.rb
 - test/test_list.rb
 has_rdoc: true
@@ -123,5 +131,6 @@ specification_version: 2
 summary: boom lets you access text snippets over your command line.
 test_files: 
 - test/test_command.rb
+- test/test_config.rb
 - test/test_item.rb
 - test/test_list.rb