kaboom 0.3.1

data/kaboom.gemspec

@@ -0,0 +1,117 @@
+## 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              = 'kaboom'
+  s.version           = '0.3.1'
+  s.date              = '2012-03-17'
+  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", "Mark Burns"]
+  s.email    = 'markthedeveloper@gmail.com'
+  s.homepage = 'https://github.com/markburns/kaboom'
+
+  ## 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", "kaboom"]
+  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.markdown]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('multi_json', "~> 1.0.3")
+  s.add_dependency('json_pure', "~> 1.5.3")
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('mocha', "~> 0.9.9")
+  s.add_development_dependency('rake', "~> 0.9.2")
+
+  ## 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[
+    CHANGELOG.markdown
+    Gemfile
+    Gemfile.lock
+    LICENSE.markdown
+    README.markdown
+    Rakefile
+    bin/boom
+    bin/kaboom
+    completion/README.md
+    completion/boom.bash
+    completion/boom.zsh
+    kaboom.gemspec
+    lib/kaboom.rb
+    lib/kaboom/color.rb
+    lib/kaboom/command.rb
+    lib/kaboom/config.rb
+    lib/kaboom/core_ext/symbol.rb
+    lib/kaboom/item.rb
+    lib/kaboom/list.rb
+    lib/kaboom/output.rb
+    lib/kaboom/platform.rb
+    lib/kaboom/remote.rb
+    lib/kaboom/storage.rb
+    lib/kaboom/storage/base.rb
+    lib/kaboom/storage/gist.rb
+    lib/kaboom/storage/json.rb
+    lib/kaboom/storage/keychain.rb
+    lib/kaboom/storage/mongodb.rb
+    lib/kaboom/storage/redis.rb
+    test/examples/config_json.json
+    test/examples/test_json.json
+    test/examples/urls.json
+    test/helper.rb
+    test/output_interceptor.rb
+    test/test_color.rb
+    test/test_command.rb
+    test/test_config.rb
+    test/test_item.rb
+    test/test_list.rb
+    test/test_platform.rb
+    test/test_remote.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/kaboom.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'fileutils'
+require 'multi_json'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'kaboom/output'
+require 'kaboom/color'
+require 'kaboom/platform'
+require 'kaboom/command'
+require 'kaboom/config'
+require 'kaboom/item'
+require 'kaboom/list'
+
+require 'kaboom/storage'
+require 'kaboom/storage/base'
+require 'kaboom/storage/json'
+require 'kaboom/storage/redis'
+require 'kaboom/storage/mongodb'
+require 'kaboom/storage/keychain'
+require 'kaboom/storage/gist'
+
+require 'kaboom/core_ext/symbol'
+require 'kaboom/remote'
+
+module Boom
+  VERSION = '0.3.1'
+
+  extend self
+
+  def storage
+    @storage ||= Boom::Storage.backend
+  end
+
+  # Public: tell Boom to use the storage specified in
+  # ~/.boom.remote.conf
+  # Returns a Config instance.
+  def use_remote remote=true
+    @config = Boom::Config.new remote
+  end
+
+  def config
+    @config ||= Boom::Config.new
+  end
+
+  def remote?
+    config.remote
+  end
+
+  def local?
+    !remote?
+  end
+end

data/lib/kaboom/color.rb

@@ -0,0 +1,52 @@
+module Boom
+  # Color collects some methods for colorizing terminal output.
+  module Color
+    extend self
+
+    CODES = {
+      :reset   => "\e[0m",
+
+      :cyan    => "\e[36m",
+      :magenta => "\e[35m",
+      :red     => "\e[31m",
+      :yellow  => "\e[33m"
+    }
+
+    # Tries to enable Windows support if on that platform.
+    #
+    # Returns nothing.
+    def self.included(other)
+      if RUBY_PLATFORM =~ /win32/ || RUBY_PLATFORM =~ /mingw32/
+        require 'Win32/Console/ANSI'
+      end
+    rescue LoadError
+      # Oh well, we tried.
+    end
+
+    # Wraps the given string in ANSI color codes
+    #
+    # string     - The String to wrap.
+    # color_code - The String representing he ANSI color code
+    #
+    # Examples
+    #
+    #   colorize("Boom!", :magenta)
+    #   # => "\e[35mBoom!\e[0m"
+    #
+    # Returns the wrapped String unless the the platform is windows and
+    # does not have Win32::Console, in which case, returns the String.
+    def colorize(string, color_code)
+      if !defined?(Win32::Console) && !!(RUBY_PLATFORM =~ /win32/ || RUBY_PLATFORM =~ /mingw32/)
+        # looks like this person doesn't have Win32::Console and is on windows
+        # just return the uncolorized string
+        return string
+      end
+      "#{CODES[color_code] || color_code}#{string}#{CODES[:reset]}"
+    end
+
+    # Set up shortcut methods to all the codes define in CODES.
+    self.class_eval(CODES.keys.reject {|color| color == :reset }.map do |color|
+      "def #{color}(string); colorize(string, :#{color}); end"
+    end.join("\n"))
+  end
+end

data/lib/kaboom/command.rb

@@ -0,0 +1,389 @@
+# coding: utf-8
+
+# 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
+      include Boom::Color
+      include Boom::Output
+
+      # Public: accesses the in-memory JSON representation.
+      #
+      # Returns a Storage instance.
+      def storage
+        Boom.storage
+      end
+
+      # Public: executes a command.
+      #
+      # args    - The actual commands to operate on. Can be as few as zero
+      #           arguments or as many as three.
+      def execute(*args)
+        command = check_if_remote args
+
+        major   = args.shift
+        minor   = args.empty? ? nil : args.join(' ')
+
+        return overview unless command
+        delegate(command, major, minor)
+      end
+
+
+      def check_if_remote args
+        command = args.shift
+
+        if command == "remote"
+          Boom.use_remote
+          command = args.shift
+        end
+        command
+      end
+
+      private :check_if_remote
+
+      # Public: gets $stdin.
+      #
+      # Returns the $stdin object. This method exists to help with easy mocking
+      # or overriding.
+      def stdin
+        $stdin
+      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
+        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
+      # Items.
+      #
+      # Returns nothing.
+      def all
+        storage.lists.each do |list|
+          output "  #{list.name}"
+          list.items.each do |item|
+            output "    #{item.short_name}:#{item.spacer} #{item.value}"
+          end
+        end
+      end
+
+      # Public: allows main access to most commands.
+      #
+      # Returns output based on method calls.
+      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 version           if command == "-v"
+        return version           if command == "--version"
+        return help              if command == 'help'
+        return help              if command[0] == 45 || command[0] == '-' # any - dash options are pleas for help
+        return echo(major,minor) if command == 'echo' || command == 'e'
+        return open(major,minor) if command == 'open' || command == 'o'
+        return random(major)     if command == 'random' || command == 'rand' || command == 'r'
+
+        # if we're operating on a List
+        if storage.list_exists?(command)
+          return delete_list(command) if major == 'delete'
+          return detail_list(command) unless major
+          unless minor == 'delete'
+            return add_item(command,major,minor) if minor
+            return add_item(command,major,stdin.read) if stdin.stat.size > 0
+            return search_list_for_item(command, major)
+          end
+        end
+
+        if minor == 'delete' and storage.item_exists?(major)
+          return delete_item(command, major)
+        end
+
+        return search_items(command) if storage.item_exists?(command)
+
+        return create_list(command, major, stdin.read) if !minor && stdin.stat.size > 0
+        return create_list(command, major, minor)
+      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
+      #
+      # Returns nothing.
+      def detail_list(name)
+        list = List.find(name)
+        list.items.sort{ |x,y| x.name <=> y.name }.each do |item|
+          output "    #{item.short_name}:#{item.spacer} #{item.value}"
+        end
+      end
+
+      # Public: opens the Item.
+      #
+      # Returns nothing.
+      def open(major, minor)
+        if storage.list_exists?(major)
+          list = List.find(major)
+          if minor
+            item = storage.items.detect { |item| item.name == minor }
+            output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
+          else
+            list.items.each { |item| Platform.open(item) }
+            output "#{cyan("Boom!")} We just opened all of #{yellow(major)} for you."
+          end
+        else
+          item = storage.items.detect { |item| item.name == major }
+          output "#{cyan("Boom!")} We just opened #{yellow(Platform.open(item))} for you."
+        end
+      end
+
+      # Public: Opens a random item
+      #
+      # Returns nothing.
+      def random(major)
+        if major.nil?
+          index = rand(storage.items.size)
+          item = storage.items[index]
+        elsif storage.list_exists?(major)
+          list = List.find(major)
+          index = rand(list.items.size)
+          item = list.items[index]
+        else
+          output "We couldn't find that list."
+        end
+        open(item.name, nil) unless item.nil?
+      end
+
+      # Public: echoes only the Item's value without copying
+      #
+      # item_name - the String term to search for in all Item names
+      #
+      # Returns nothing
+      def echo(major, minor)
+        unless minor
+          item = storage.items.detect do |item|
+            item.name == major
+          end
+          return output "#{yellow(major)} #{red("not found")}" unless item
+        else
+          list = List.find(major)
+          item = list.find_item(minor)
+          return output "#{yellow(minor)} #{red("not found in")} #{yellow(major)}" unless item
+        end
+        output item.value
+      end
+
+      # Public: add a new List.
+      #
+      # name  - the String name of the List.
+      # item  - the String name of the Item
+      # value - the String value of Item
+      #
+      # Example
+      #
+      #   Commands.list_create("snippets")
+      #   Commands.list_create("hotness", "item", "value")
+      #
+      # Returns the newly created List and creates an item when asked.
+      def create_list(name, item = nil, value = nil)
+        lists = (storage.lists << List.new(name))
+        storage.lists = lists
+        output "#{cyan("Boom!")} Created a new list called #{yellow(name)}."
+        save
+        add_item(name, item, value) unless value.nil?
+      end
+
+      # Public: remove a named List.
+      #
+      # name - the String name of the List.
+      #
+      # Example
+      #
+      #   Commands.delete_list("snippets")
+      #
+      # Returns nothing.
+      def delete_list(name)
+        output "You sure you want to delete everything in #{yellow(name)}? (y/n):"
+        if $stdin.gets.chomp == 'y'
+          List.delete(name)
+          output "#{cyan("Boom!")} Deleted all your #{yellow(name)}."
+          save
+        else
+          output "Just kidding then."
+        end
+      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 = List.find(list)
+        list.add_item(Item.new(name,value))
+        output "#{cyan("Boom!")} #{yellow(name)} in #{yellow(list.name)} is #{yellow(value)}. Got it."
+        save
+      end
+
+      # Public: remove a named Item.
+      #
+      # list_name - the String name of the List.
+      # name      - the String name of the Item.
+      #
+      # Example
+      #
+      #   Commands.delete_item("a-list-name", "an-item-name")
+      #
+      # Returns nothing.
+      def delete_item(list_name,name)
+        if storage.list_exists?(list_name)
+          list = List.find(list_name)
+          if list.delete_item(name)
+            output "#{cyan("Boom!")} #{yellow(name)} is gone forever."
+            save
+          else
+            output "#{yellow(name)} #{red("not found in")} #{yellow(list_name)}"
+          end
+        else
+          output "We couldn't find that list."
+        end
+      end
+
+      # 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 "#{cyan("Boom!")} We just copied #{yellow(Platform.copy(item))} to your clipboard."
+      end
+
+      # Public: search for an Item in a particular list by name. Drops the
+      # corresponding entry into your clipboard if found.
+      #
+      # list_name - the String name of the List in which to scope the search
+      # item_name - the String term to search for in all Item names
+      #
+      # Returns the matching Item if found.
+      def search_list_for_item(list_name, item_name)
+        list = List.find(list_name)
+        item = list.find_item(item_name)
+
+        if item
+          output "#{cyan("Boom!")} We just copied #{yellow(Platform.copy(item))} to your clipboard."
+        else
+          output "#{yellow(item_name)} #{red("not found in")} #{yellow(list_name)}"
+        end
+      end
+
+      # Public: save in-memory data to disk.
+      #
+      # Returns whether or not data was saved.
+      def save
+        storage.save
+      end
+
+      # Public: the version of boom that you're currently running.
+      #
+      # Returns a String identifying the version number.
+      def version
+        output "You're running boom #{Boom::VERSION}. Congratulations!"
+      end
+
+      # Public: launches JSON file in an editor for you to edit manually.
+      #
+      # Returns nothing.
+      def edit
+        if storage.respond_to?("json_file")
+          output "#{cyan("Boom!")} #{Platform.edit(storage.json_file)}"
+        else
+          output "This storage backend does not store #{cyan("Boom!")} data on your computer"
+        end
+      end
+
+      # Public: prints all the commands of boom.
+      #
+      # Returns nothing.
+      def help
+        text = %{
+          - boom: help ---------------------------------------------------
+
+          boom                          display high-level overview
+          boom all                      show all items in all lists
+          boom edit                     edit the boom JSON file in $EDITOR
+          boom help                     this help text
+          boom 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
+          boom <list> delete            deletes a list
+
+          boom <list> <name> <value>    create a new list item
+          boom <name>                   copy item's value to clipboard
+          boom <list> <name>            copy item's value to clipboard
+          boom open <name>              open item's url in browser
+          boom open <list> <name>       open all item's url in browser for a list
+          boom random                   open a random item's url in browser
+          boom random <list>            open a random item's url for a list in browser
+          boom echo <name>              echo the item's value without copying
+          boom echo <list> <name>       echo the item's value without copying
+          boom <list> <name> delete     deletes an item
+
+          all other documentation is located at:
+            https://github.com/holman/boom
+        }.gsub(/^ {8}/, '') # strip the first eight spaces of every line
+
+        output text
+      end
+
+    end
+  end
+end