kaboom 0.3.1

data/lib/kaboom/storage.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+#
+# Storage is the interface between multiple Backends. You can use Storage
+# directly without having to worry about which Backend is in use.
+#
+module Boom
+  module Storage
+
+    def self.backend=(backend)
+      backend = backend.capitalize
+      Boom::Storage.const_get(backend)
+      Boom.config.attributes['backend'] = backend.downcase
+      Boom.config.save
+    end
+
+    def self.backend
+      Boom::Storage.const_get(Boom.config.attributes['backend'].capitalize).new
+    end
+
+  end
+end

data/lib/kaboom/storage/base.rb

@@ -0,0 +1,91 @@
+# 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
+        Boom::Remote.allowed? self
+        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
+
+      def handle error, message
+        case error
+        when NoMethodError
+          output cyan config_text
+        when NameError
+          output message
+        end
+      end
+    end
+  end
+end

data/lib/kaboom/storage/gist.rb

@@ -0,0 +1,125 @@
+# 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 self.sample_config
+        %({
+             "backend": "gist",
+             "gist": {
+               "username": "your_github_username",
+               "password": "your_github_password"
+             }
+           }
+         )
+      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/kaboom/storage/json.rb

@@ -0,0 +1,76 @@
+# 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
+      include Output
+      include Color
+
+      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
+
+      def self.sample_config
+        %({"backend":"json"})
+      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/kaboom/storage/keychain.rb

@@ -0,0 +1,135 @@
+# 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