kaboom 0.3.1

data/lib/kaboom/config.rb

@@ -0,0 +1,116 @@
+# 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"
+    REMOTE_FILE = FILE.gsub(/\.conf$/, ".remote.conf")
+
+    #if set to true then we will use a different config file for storage
+    #engine
+    attr_accessor :remote
+
+    # 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: an alias for accessing Boom.config.attributes[key]
+    # like Boom.config[key] instead
+    #
+    # Returns the value in the attributes hash
+    def [] key
+      attributes[key]
+    end
+
+    # 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 remote=false
+      @remote = remote
+      bootstrap unless File.exist?(file)
+      load_attributes
+    end
+
+    # Public: accessor for the configuration file.
+    #
+    # Returns the String file path.
+    def file
+      remote ? REMOTE_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 = MultiJson.decode(File.new(file, 'r').read)
+    end
+
+    # Public: writes the in-memory JSON Hash to disk.
+    #
+    # Returns nothing.
+    def save
+      json = MultiJson.encode(attributes)
+      File.open(file, 'w') {|f| f.write(json) }
+    end
+
+    def invalid_message
+      %(#{red "Is your config correct? You said:"}
+
+      #{File.read Boom.config.file}
+
+      #{cyan "Our survey says:"}
+
+      #{self.class.sample_config}
+
+      #{yellow "Go edit "} #{Boom.config.file +  yellow(" and make it all better") }
+      ).gsub(/^ {8}/, '') # strip the first eight spaces of every line
+    end
+  end
+end

data/lib/kaboom/core_ext/symbol.rb

@@ -0,0 +1,7 @@
+unless Symbol.method_defined?(:to_proc)
+  class Symbol
+    def to_proc
+      Proc.new { |obj, *args| obj.send(self, *args) }
+    end
+  end
+end

data/lib/kaboom/item.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+# 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", "https://github.com")
+    #
+    # Returns the newly initialized Item.
+    def initialize(name,value)
+      @name = name
+      @value = value
+    end
+
+    # Public: the shortened String name of the Item. Truncates with ellipses if
+    # larger.
+    #
+    # Examples
+    #
+    #   item = Item.new("github's home page","https://github.com")
+    #   item.short_name
+    #   # => 'github's home p…'
+    #
+    #   item = Item.new("github","https://github.com")
+    #   item.short_name
+    #   # => 'github'
+    #
+    # Returns the shortened name.
+    def short_name
+      name.length > 15 ? "#{name[0..14]}…" : name[0..14]
+    end
+
+    # Public: the amount of consistent spaces to pad based on Item#short_name.
+    #
+    # Returns a String of spaces.
+    def spacer
+      name.length > 15 ? '' : ' '*(15-name.length+1)
+    end
+
+    # Public: only return url part of value - if no url has been
+    # detected returns value.
+    #
+    # Returns a String which preferably is a URL.
+    def url
+      @url ||= value.split(/\s+/).detect { |v| v =~ %r{\A[a-z0-9]+:\S+}i } || 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/kaboom/list.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+# 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: accesses the in-memory JSON representation.
+    #
+    # Returns a Storage instance.
+    def self.storage
+      Boom.storage
+    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.  If the item name is already
+    # defined, then the value will be replaced
+    #
+    # item - the Item object to associate with this List.
+    #
+    # Returns the current set of items.
+    def add_item(item)
+      delete_item(item.name) if find_item(item.name)
+      @items << item
+    end
+
+    # Public: finds any given List by name.
+    #
+    # name - String name of the list to search for
+    #
+    # Returns the first instance of List that it finds.
+    def self.find(name)
+      storage.lists.find { |list| list.name == name }
+    end
+
+    # Public: deletes a List by name.
+    #
+    # name - String name of the list to delete
+    #
+    # Returns whether one or more lists were removed.
+    def self.delete(name)
+      previous = storage.lists.size
+      storage.lists = storage.lists.reject { |list| list.name == name }
+      previous != storage.lists.size
+    end
+
+    # Public: deletes an Item by name.
+    #
+    # name - String name of the item to delete
+    #
+    # Returns whether an item was removed.
+    def delete_item(name)
+      previous = items.size
+      items.reject! { |item| item.name == name}
+      previous != items.size
+    end
+
+    # Public: finds an Item by name. If the name is typically truncated, also
+    # allow a search based on that truncated name.
+    #
+    # name - String name of the Item to find
+    #
+    # Returns the found item
+    def find_item(name)
+      items.find do |item|
+        item.name == name ||
+        item.short_name.gsub('…','') == name.gsub('…','')
+      end
+    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/kaboom/output.rb

@@ -0,0 +1,13 @@
+module Boom
+  module Output
+    # 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
+  end
+end

data/lib/kaboom/platform.rb

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+# Platform is a centralized point to shell out platform specific functionality
+# like clipboard access or commands to open URLs.
+#
+#
+# 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 Platform
+    class << self
+      # Public: tests if currently running on darwin.
+      #
+      # Returns true if running on darwin (MacOS X), else false
+      def darwin?
+        !!(RUBY_PLATFORM =~ /darwin/)
+      end
+
+      # Public: tests if currently running on windows.
+      #
+      # Apparently Windows RUBY_PLATFORM can be 'win32' or 'mingw32'
+      #
+      # Returns true if running on windows (win32/mingw32), else false
+      def windows?
+        !!(RUBY_PLATFORM =~ /mswin|mingw/)
+      end
+
+      # Public: returns the command used to open a file or URL
+      # for the current platform.
+      #
+      # Currently only supports MacOS X and Linux with `xdg-open`.
+      #
+      # Returns a String with the bin
+      def open_command
+        if darwin?
+          'open'
+        elsif windows?
+          'start'
+        else
+          'xdg-open'
+        end
+      end
+
+      # Public: opens a given Item's value in the browser. This
+      # method is designed to handle multiple platforms.
+      #
+      # Returns a String of the Item value.
+      def open(item)
+        unless windows?
+          system("#{open_command} '#{item.url.gsub("\'","'\\\\''")}'")
+        else
+          system("#{open_command} #{item.url.gsub("\'","'\\\\''")}")
+        end
+
+        item.value
+      end
+
+      # Public: returns the command used to copy a given Item's value to the
+      # clipboard for the current platform.
+      #
+      # Returns a String with the bin
+      def copy_command
+        if darwin?
+          'pbcopy'
+        elsif windows?
+          'clip'
+        else
+          'xclip -selection clipboard'
+        end
+      end
+
+      # Public: copies a given Item's value to the clipboard. This method is
+      # designed to handle multiple platforms.
+      #
+      # Returns the String value of the Item.
+      def copy(item)
+        IO.popen(copy_command,"w") {|cc|  cc.write(item.value)}
+        item.value
+      end
+
+      # Public: opens the JSON file in an editor for you to edit. Uses the
+      # $EDITOR environment variable, or %EDITOR% on Windows for editing.
+      # This method is designed to handle multiple platforms.
+      # If $EDITOR is nil, try to open using the open_command.
+      #
+      # Returns a String with a helpful message.
+      def edit(json_file)
+        unless $EDITOR.nil?
+          unless windows?
+            system("`echo $EDITOR` #{json_file} &")
+          else
+            system("start %EDITOR% #{json_file}")
+          end
+        else
+          system("#{open_command} #{json_file}")
+        end
+
+        "Make your edits, and do be sure to save."
+      end
+    end
+  end
+end

data/lib/kaboom/remote.rb

@@ -0,0 +1,47 @@
+module Boom
+  module Remote
+    include Output
+    include Color
+
+    def allowed_storage_types
+      [Boom::Storage::Gist, Boom::Storage::Mongodb, Boom::Storage::Redis]
+    end
+
+    # Returns true if the user is using a sensible seeming storage backend
+    # Params storage, the current storage instance
+    # else exits with a warning if not
+    def allowed? storage
+      return true if Boom.local?
+      return true if allowed_storage_types.include? storage.class
+
+      output error_message storage
+      false
+    end
+
+    def error_message storage
+      %(
+        #{red("<<----BOOOOOM!!!----->>>> ")} (as in explosion, rather than fast)
+        You probably don't want to use the #{storage.class} storage whilst
+        using boom in remote mode. Your config looks akin to:
+
+        #{red File.read Boom.config.file}
+
+        but things might be better with something a little more like:
+
+        #{cyan Boom::Storage::Redis.sample_config}
+
+        or
+
+        #{cyan Boom::Storage::Mongodb.sample_config}
+
+        Now head yourself on over to #{yellow Boom.config.file}
+        and edit some goodness into it
+
+        Meanwhile, please enjoy your ordinary boom service:
+        ___________________________________________________
+
+      ).gsub(/^ {8}/, '')
+    end
+    extend self
+  end
+end