boom 0.2.4 → 0.3.0

data/lib/boom/storage/base.rb

@@ -1,81 +0,0 @@
-# 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/gist.rb

@@ -1,114 +0,0 @@
-# coding: utf-8
-#
-# Gist backend for Boom.
-#
-# Your .boom.conf file should look like this:
-#
-#   {
-#     "backend": "gist",
-#     "gist": {
-#       "username": "your_github_username",
-#       "password": "your_github_password"
-#     }
-#   }
-#
-# There are two optional keys which can be under "gist":
-#
-#   gist_id - The ID of an existing Gist to use. If not
-#     present, a Gist will be created the first time
-#     Boom is run and will be persisted to the config.
-#   public - Makes the Gist public. An absent value or
-#     any value other than boolean true will make
-#     the Gist private.
-#
-
-module Boom
-  module Storage
-    class Gist < Base
-
-      def bootstrap
-        begin
-          require "httparty"
-
-          self.class.send(:include, HTTParty)
-          self.class.base_uri "https://api.github.com"
-        rescue LoadError
-          puts "The Gist backend requires HTTParty: gem install httparty"
-          exit
-        end
-
-        unless Boom.config.attributes["gist"]
-          puts 'A "gist" data structure must be defined in ~/.boom.conf'
-          exit
-        end
-
-        set_up_auth
-        find_or_create_gist
-      end
-
-      def populate
-        @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
-
-      def save
-        self.class.post("/gists/#{@gist_id}", request_params)
-      end
-
-      private
-
-      def set_up_auth
-        username, password = Boom.config.attributes["gist"]["username"], Boom.config.attributes["gist"]["password"]
-
-        if username and password
-          self.class.basic_auth(username, password)
-        else
-          puts "GitHub username and password must be defined in ~/.boom.conf"
-          exit
-        end
-      end
-
-      def find_or_create_gist
-        @gist_id = Boom.config.attributes["gist"]["gist_id"]
-        @public = Boom.config.attributes["gist"]["public"] == true
-
-        if @gist_id.nil? or @gist_id.empty?
-          response = self.class.post("/gists", request_params)
-        else
-          response = self.class.get("/gists/#{@gist_id}", request_params)
-        end
-
-        @storage = MultiJson.decode(response["files"]["boom.json"]["content"]) if response["files"] and response["files"]["boom.json"]
-
-        unless @storage
-          puts "Boom data could not be obtained"
-          exit
-        end
-
-        unless @gist_id
-          Boom.config.attributes["gist"]["gist_id"] = @gist_id = response["id"]
-          Boom.config.save
-        end
-      end
-
-      def request_params
-        {
-          :body => MultiJson.encode({
-            :description => "boom!",
-            :public => @public,
-            :files => { "boom.json" => { :content => MultiJson.encode(to_hash) } }
-          })
-        }
-      end
-    end
-  end
-end

data/lib/boom/storage/json.rb

@@ -1,69 +0,0 @@
-# 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 = MultiJson.decode(File.new(json_file, 'r').read)
-      
-        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
-        MultiJson.encode(to_hash)
-      end
-
-    end
-  end
-end

data/lib/boom/storage/keychain.rb

@@ -1,135 +0,0 @@
-# coding: utf-8
-
-# Keychain provides methods for using Mac OS X's Keychain as a storage option.
-# It saves lists as Keychain files in ~/Library/Keychains with the filename
-# format being: "Boom.list.mylist.keychain"
-#
-module Boom
-  module Storage
-    class Keychain < Base
-
-      KEYCHAIN_FORMAT = %r{Boom\.list\.(.+)\.keychain}
-
-      # Opens Keychain app when json_file is called during `boom edit`
-      #
-      # Returns nothing
-      def open_keychain_app
-        `open /Applications/Utilities/'Keychain Access.app' &`
-      end
-
-      alias_method :json_file, :open_keychain_app
-
-      # Boostraps Keychain by checking if you're using a Mac which is a prereq
-      #
-      # Returns
-      def bootstrap
-        raise RuntimeError unless is_mac?
-      rescue
-        puts('No Keychain utility to access, maybe try another storage option?')
-        exit
-      end
-      
-      # Asks if you're using Mac OS X
-      #
-      # Returns true on a Mac
-      def is_mac?
-        return Boom::Platform.darwin?
-      end
-
-      # Populate the in-memory store with all the lists and items from Keychain
-      #
-      # Returns Array of keychain names, i.e. ["Boom.list.mylist.keychain"]
-      def populate
-        stored_keychain_lists.each do |keychain|
-          @lists << list = List.new(keychain.scan(KEYCHAIN_FORMAT).flatten.first)
-          extract_keychain_items(keychain).each do |name|
-            list.add_item(Item.new(name, extract_keychain_value(name, keychain)))
-          end
-        end
-      end
-
-      # Saves the data from memory to the correct Keychain
-      #
-      # Returns nothing
-      def save
-        @lists.each do |list|
-          keychain_name = list_to_filename(list.name)
-          create_keychain_list(keychain_name) unless stored_keychain_lists.include?(keychain_name)
-          unless list.items.empty?
-            list.items.each do |item|
-              store_item(item, keychain_name)
-            end
-          end
-          delete_unwanted_items(list)
-        end
-        delete_unwanted_lists
-      rescue RuntimeError
-        puts(e "Couldn't save to your keychain, check Console.app or above for relevant messages")
-      end
-
-
-      private
-
-      # Returns an Array of keychains stored in ~/Library/Keychains:
-      # => ["Boom.list.mylist.keychain"]
-      def stored_keychain_lists
-        @stored_keychain_lists ||= `security -q list-keychains |grep Boom.list` \
-          .split(/[\/\n\"]/).select {|kc| kc =~ KEYCHAIN_FORMAT}
-      end
-
-      # Create the keychain list "Boom.list.mylist.keychain" in ~/Library/Keychains
-      def create_keychain_list(keychain_name)
-        `security -q create-keychain #{keychain_name}`
-      end
-
-      # Saves the individual item's value to the right list/keychain
-      def store_item(item, keychain_name)
-        `security 2>/dev/null -q add-generic-password -a '#{item.name}' -s '#{item.name}' -w '#{item.value}' #{keychain_name}`
-      end
-
-      # Retrieves the value of a particular item in a list
-      def extract_keychain_value(item_name, keychain)
-        `security 2>&1 >/dev/null find-generic-password -ga '#{item_name}' #{keychain}`.chomp.split('"').last
-      end
-
-      # Gets all items in a particular list
-      def extract_keychain_items(keychain_name)
-        @stored_items ||= {}
-        @stored_items[keychain_name] ||= `security dump-keychain -a #{keychain_name} |grep acct` \
-          .split(/\s|\\n|\\"|acct|<blob>=|\"/).reject {|f| f.empty?}
-      end
-
-      # Converts list name to the corresponding keychain filename format based
-      # on the KEYCHAIN_FORMAT
-      def list_to_filename(list_name)
-        KEYCHAIN_FORMAT.source.gsub(/\(\.\+\)/, list_name).gsub('\\','')
-      end
-
-      # Delete's a keychain file
-      def delete_list(keychain_filename)
-        `security delete-keychain #{keychain_filename}`
-      end
-
-      # Delete's all keychain files you don't want anymore
-      def delete_unwanted_lists
-        (stored_keychain_lists - @lists.map {|list| list_to_filename(list.name)}).each do |filename|
-          delete_list(filename)
-        end
-      end
-
-      # Removes unwanted items in a list
-      # security util doesn't have a delete password option so we'll have to
-      # drop it and recreate it with what is in memory
-      def delete_unwanted_items(list)
-        filename = list_to_filename(list.name)
-        if (list.items.size < extract_keychain_items(filename).size)
-          delete_list(filename)
-          create_keychain_list(filename)
-          list.items.each do |item|
-            store_item(item, filename)
-          end unless list.items.empty?
-        end
-      end
-    end
-  end
-end

data/lib/boom/storage/mongodb.rb

@@ -1,84 +0,0 @@
-# coding: utf-8
-
-# Storage adapter that saves data from boom to MongoDB instead of JSON file.
-begin
-  require 'mongo'
-rescue LoadError
-end
-
-module Boom
-  module Storage
-    class Mongodb < Base
-      
-      # Public: Initialize MongoDB connection and check dep.
-      #
-      # Returns Mongo connection
-      def mongo
-        @mongo ||= ::Mongo::Connection.new(
-          Boom.config.attributes["mongodb"]["host"],
-          Boom.config.attributes["mongodb"]["port"]
-        ).db(Boom.config.attributes["mongodb"]["database"])
-        
-        @mongo.authenticate(
-          Boom.config.attributes['mongodb']['username'], 
-          Boom.config.attributes['mongodb']['password']
-        )
-      
-        # Return connection
-        @mongo
-      rescue NameError => e
-        puts "You don't have the Mongo gem installed yet:\n  gem install mongo"
-       exit
-      end
-      
-      # Public: The MongoDB collection
-      #
-      # Returns the MongoDB collection
-      def collection
-        @collection ||= mongo.collection(Boom.config.attributes["mongodb"]["collection"])
-      end
-      
-      # Public: Bootstrap
-      #
-      # Returns
-      def bootstrap
-        collection.insert("boom" => '{"lists": [{}]}') if collection.find_one.nil?
-      end   
-
-      # Public: Populates the memory list from MongoDB
-      #
-      # Returns nothing
-      def populate
-        storage = MultiJson.decode(collection.find_one['boom']) || []
-              
-        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: Save to MongoDB
-      #
-      # Returns Mongo ID
-      def save
-        doc = collection.find_one()
-        collection.update({"_id" => doc["_id"]}, {'boom' => to_json})
-      end
-      
-      # Public: Convert to JSON
-      #
-      # Returns
-      def to_json
-       MultiJson.encode(to_hash)
-      end
-      
-    end
-  end
-end

data/lib/boom/storage/redis.rb

@@ -1,72 +0,0 @@
-# coding: utf-8
-#
-# Sup, Redis.
-#
-begin
-  require 'digest'
-  require 'redis'
-  require 'uri'
-rescue LoadError
-end
-
-module Boom
-  module Storage
-    class Redis < Base
-
-      def redis
-        uri = URI.parse(Boom.config.attributes['uri'] || '')
-
-        @redis ||= ::Redis.new :host     => (uri.host     || Boom.config.attributes["redis"]["host"]),
-                               :port     => (uri.port     || Boom.config.attributes["redis"]["port"]),
-                               :user     => (uri.user     || Boom.config.attributes["redis"]["user"]),
-                               :password => (uri.password || Boom.config.attributes["redis"]["password"])
-      rescue NameError => e
-        puts "You don't have Redis installed yet:\n  gem install redis"
-        exit
-      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/test/examples/config_json.json

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

data/test/examples/test_json.json

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

data/test/examples/urls.json

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

data/test/helper.rb

@@ -1,24 +0,0 @@
-# coding: utf-8
-
-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'
-
-def boom_json(name)
-  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_color.rb

@@ -1,30 +0,0 @@
-require 'helper'
-
-class TestColor < Test::Unit::TestCase
-
-  def test_colorize
-    assert_equal "\e[35mBoom!\e[0m",
-      Boom::Color.colorize("Boom!", :magenta)
-  end
-
-  def test_magenta
-    assert_equal "\e[35mMagenta!\e[0m",
-      Boom::Color.magenta("Magenta!")
-  end
-
-  def test_red
-    assert_equal "\e[31mRed!\e[0m",
-      Boom::Color.red("Red!")
-  end
-
-  def test_yellow
-    assert_equal "\e[33mYellow!\e[0m",
-      Boom::Color.yellow("Yellow!")
-  end
-
-  def test_cyan
-    assert_equal "\e[36mCyan!\e[0m",
-      Boom::Color.cyan("Cyan!")
-  end
-
-end