command-line-favs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6bd5d33d21e6787c2c179a69d1f9fc8eec6f210c
+  data.tar.gz: 1d56cca67075349dc1a2ae72255e4150ab39a099
+SHA512:
+  metadata.gz: 0e4c8b52eae961faafdf53d09df3b6f27f29fd29ef81239844a55f8265eea051aea1ed053773838c228696da830b1af6884200e7325eea5f825b662109d572ab
+  data.tar.gz: a34a21249d9765193e709570dcbc48947881ccc075ba686493e245542ff1a874e360589d27f7ba182e11a8f09803cacb9a9327775674306e5b8eb7dd15b61591

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+results.html
+pkg
+html
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in command-line-favs.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    command-line-favs (0.0.1)
+      highline (~> 1.6)
+      methadone (~> 1.4)
+      parseconfig (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aruba (0.5.4)
+      childprocess (>= 0.3.6)
+      cucumber (>= 1.1.1)
+      rspec-expectations (>= 2.7.0)
+    builder (3.2.2)
+    childprocess (0.5.3)
+      ffi (~> 1.0, >= 1.0.11)
+    cucumber (1.3.14)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 2.12)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.1.1)
+    diff-lcs (1.2.5)
+    ffi (1.9.3)
+    gherkin (2.12.2)
+      multi_json (~> 1.3)
+    highline (1.6.21)
+    json (1.8.1)
+    methadone (1.4.0)
+      bundler
+    multi_json (1.10.0)
+    multi_test (0.1.1)
+    parseconfig (1.0.4)
+    rake (0.9.6)
+    rdoc (4.1.1)
+      json (~> 1.4)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aruba (~> 0.5)
+  bundler (~> 1.6)
+  command-line-favs!
+  rake (~> 0.9)
+  rdoc (~> 4.1)

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Name: command-line-favs
+Copyright (c) 2014 Jon Bake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# Command Line Favs
+
+Command Line Favs is a CLI utility for organizing your commonly used shell commands.  Commands are stored as a **Command Name** (think Alias) to **Command** map within your ~/.favs file and can be organized into groups.
+
+A *~/.favs* file might look something like:
+
+```
+#comments are supported so are un-grouped commands like this one
+#positional-based substitution is also suported
+pr = "echo $0"
+
+#a group for all your ssh commands
+[ssh]
+google = "ssh -P 25001 jonmbake@74.125.225.224"
+work = "ssh jbake@207.171.189.228"
+
+[dev]
+build = "mvn -Pdev -U clean install"
+arq = "mvn -Parq-jbossas-remote clean verify -Pdev"
+
+[Demo]
+files_mod = "hg status | awk 'NR>2{print $2}' | xargs cat"
+```
+
+You get the idea.
+
+## Getting help
+
+A CLI utility is not complete without some decent help/documentation.  Running *fav* with the *--help* flag will display all available options:
+
+```
+$ fav --help
+```
+
+The typically format for running a fav command is *fav [options] command_name*, where *options* usually contains an *Action* flag:
+
+## Fav a command
+
+A command is added as a *Fav* by using the *-a* action flag.  The following command will add a command as a *Fav*:
+
+```
+$ fav -a 'echo I am a Test Command' tc
+```
+
+Or to *Fav* a command to a group;
+
+```
+$ fav -a 'echo I am a Test Command in a group' -g Demo tgc
+```
+
+**In the event that the group does not yet exist when adding a *Fav* to group, the group will be automatically added.**
+
+You can also always manually add a *Fav* by modifying your *~/.favs* file.
+
+### String Substitution
+
+There is support for position string substitution; the syntax is '$<position>' (see the *pr* command in the examle .favs file).
+
+## Remove a Fav
+
+A command is removed as a *Fav* by using the *-r* action flag.  The following command will remove a command as a *Fav*:
+
+```
+$ fav -r tc
+```
+
+Or remove a group command:
+
+```
+$ fav -r -g Demo files_mod
+```
+
+You can also always manually remove a *Fav* by modifying your *~/.favs* file.
+
+## List Avaliable Favs
+
+List favs within a group:
+
+```
+fav -ls -g ssh
+```
+
+List all commands:
+
+```
+fav -ls -g
+```
+## Run a Fav
+
+To run a *non-grouped* command:
+
+```
+fav tc
+```
+
+To run a *single* grouped command:
+
+```
+$ fav -g TestGroup tgc
+```
+
+Or run the *entire* group of commands:
+
+```
+$ fav -g TestGroup --no_prompt
+```
+
+When running an entire group of commands the default behavior is to prompt on each command.  This can be overridden by supplying the *--no_prompt* flag.

data/README.rdoc

@@ -0,0 +1,23 @@
+= command-line-favs - DESCRIBE YOUR GEM
+
+Author::  YOUR NAME (YOUR EMAIL)
+Copyright:: Copyright (c) 2014 YOUR NAME
+
+
+License:: mit, see LICENSE.txt
+
+
+
+DESCRIBE YOUR GEM HERE
+
+== Links
+
+* {Source on Github}[LINK TO GITHUB]
+* RDoc[LINK TO RDOC.INFO]
+
+== Install
+
+== Examples
+
+== Contributing
+

data/Rakefile

@@ -0,0 +1,61 @@
+def dump_load_path
+  puts $LOAD_PATH.join("\n")
+  found = nil
+  $LOAD_PATH.each do |path|
+    if File.exists?(File.join(path,"rspec"))
+      puts "Found rspec in #{path}"
+      if File.exists?(File.join(path,"rspec","core"))
+        puts "Found core"
+        if File.exists?(File.join(path,"rspec","core","rake_task"))
+          puts "Found rake_task"
+          found = path
+        else
+          puts "!! no rake_task"
+        end
+      else
+        puts "!!! no core"
+      end
+    end
+  end
+  if found.nil?
+    puts "Didn't find rspec/core/rake_task anywhere"
+  else
+    puts "Found in #{path}"
+  end
+end
+require 'bundler'
+require 'rake/clean'
+
+require 'rake/testtask'
+
+require 'cucumber'
+require 'cucumber/rake/task'
+gem 'rdoc' # we need the installed RDoc gem, not the system one
+require 'rdoc/task'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/tc_*.rb'
+end
+
+
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty --no-source -x"
+  t.fork = false
+end
+
+Rake::RDocTask.new do |rd|
+  
+  rd.main = "README.rdoc"
+  
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+end
+
+task :default => [:test,:features]
+

data/bin/fav

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'methadone'
+require 'fav.rb'
+
+class App
+  include Methadone::Main
+  include Methadone::CLILogging
+  include Methadone::SH
+
+  main do |command_name, *command_args|
+    cmd = Fav::CommandFactory.makeCommand(options, command_name, command_args)
+    cmd.run!
+  end
+
+  description "A utility for organizing your commonly used shell commands. Commands are stored in ~/.favs."
+
+  #Define flags
+  on("-a COMMAND_TEXT","--add", "Add a command to the list of favorites")
+  on("-ls", "--list", "List available commands")
+  on("-g GROUP_NAME","--group", "If used with -a flag, will add command to group. Otherwise will run command within group")
+  on("-r","--remove", "Remove a command from the list of favorites")
+  #
+  # Specify switches via:
+  on("--no_prompt", "Skip prompting when running a group of commands")
+  #
+  # Or, just call OptionParser methods on opts
+  #
+  # Require an argument
+  arg :command_name, "Name of command", :optional
+  #
+  # # Make an argument optional
+  # arg :optional_arg, :optional
+
+  version Fav::VERSION
+
+  @log_level = Logger::DEBUG
+  logger.level = Logger::DEBUG
+
+  go!
+end

data/command-line-favs.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fav/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "command-line-favs"
+  spec.version       = Fav::VERSION
+  spec.authors       = ["Jon Bake"]
+  spec.email         = ["jmb@jonbake.com"]
+  spec.summary       = %q{A CLI utility for organizing your commonly used shell commands.}
+  spec.description      = %q{Commands are stored as a Command Name to Command map within your ~/.favs file and can be organized into groups.  Stored commands can then be easily ran.}
+  spec.homepage      = "https://github.com/jonmbake/command-line-favs"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency('rdoc', '~> 4.1')
+  spec.add_development_dependency('aruba', '~> 0.5')
+  spec.add_development_dependency('rake', '~> 0.9')
+  spec.add_dependency('methadone', '~> 1.4')
+  spec.add_dependency('parseconfig', '~> 1.0')
+  spec.add_dependency('highline', '~> 1.6')
+end

data/features/command-line-favs.feature

@@ -0,0 +1,138 @@
+Feature: Run and save commands
+  In order to organize and run commonly-used commands
+  I want to save commands in an organized fashion
+    And to be able to invoke any saved command easily
+  So I don't have the hassle of creating a bunch of unorganized aliases
+ 
+  Scenario: Basic UI
+    When I get help for "fav"
+    Then the exit status should be 0
+      And the banner should be present
+      And there should be a one line summary of what the app does
+      And the banner should include the version
+      And the banner should document that this app takes options
+      And the banner should document that this app's arguments are:
+        |command_name|which is required|
+
+  Scenario: Add a Command
+    When I run `fav -a 'man cp' mc`
+    Then the ungrouped command "man cp" is added with name "mc"
+
+  Scenario: Add a Command to a Group
+    When I run `fav -a 'ls -l' -g TestGroup gr`
+    Then the command "ls -l" is added with name "gr" to the group "TestGroup"
+
+  Scenario: Remove an Ungrouped Command
+    Given a file named "/tmp/home/.favs" with:
+      """
+      ef = "echo Foo"
+      eb = "echo Bar"
+      """
+    When I run `fav -r ef`
+    Then the command with name "ef" no longer exists as a fav
+      And the ungrouped command "echo Bar" is added with name "eb"
+
+  Scenario: Remove a Grouped Command
+    Given a file named "/tmp/home/.favs" with:
+      """
+      [test]
+      ef = "echo Foo"
+      eb = "echo Bar"
+      """
+    When I run `fav -g test -r ef`
+    Then the command with name "ef" no longer exists as a fav in the group "test"
+      And the command "echo Bar" is added with name "eb" to the group "test"
+
+  Scenario: Run a Command
+    Given a file named "/tmp/home/.favs" with:
+      """
+      cpt = "touch /tmp/home/test.txt"
+      """
+    When I run `fav cpt`
+    Then the file "test.txt" exists in "/tmp/home"
+
+  Scenario: Run a Grouped Command
+    Given a file named "/tmp/home/.favs" with:
+      """
+      [test]
+      cpt = "touch /tmp/home/test2.txt"
+      """
+    When I run `fav -g test cpt`
+    Then the file "test2.txt" exists in "/tmp/home"
+
+  Scenario: Run an entire group of commands
+    Given a file named "/tmp/home/.favs" with:
+      """
+      [test]
+      cpt2 = "touch /tmp/home/test2.txt"
+      cpt = "touch /tmp/home/test.txt"
+      """
+    When I run `fav -g test --no_prompt`
+    Then the file "test2.txt" exists in "/tmp/home"
+      And the file "test.txt" exists in "/tmp/home"
+
+  Scenario: Run a command that prepends text to the end
+    Given a file named "/tmp/home/.favs" with:
+      """
+      e = "echo $0"
+      """
+    When I run `fav e 'foo'`
+    Then it should pass with:
+      """
+      foo
+      """
+
+  Scenario: Add a Command without a Command Name
+    When I run `fav -a 'echo I am a command'`
+      Then it should fail with:
+      """
+      Must specify command name when adding a fav.
+      """
+
+  Scenario: Remove a Command without a Command Name
+    When I run `fav -r`
+      Then it should fail with:
+      """
+      Must specify command name when removing a fav.
+      """
+
+  Scenario: Run a command for a group that doesn't exist
+    When I run `fav -g NotAGroup cmd`
+      Then it should fail with:
+      """
+      Specified group does not exist.
+      """
+
+  Scenario: List commands within a group
+    Given a file named "/tmp/home/.favs" with:
+      """
+      ug = "echo ungrouped"
+      [test]
+      ef = "echo Foo"
+      eb = "echo Bar"
+      """
+    When I run `fav -ls -g test`
+    Then it should pass with exactly:
+      """
+      ef = "echo Foo"
+      eb = "echo Bar"
+
+      """
+
+  Scenario: List all commands
+    Given a file named "/tmp/home/.favs" with:
+      """
+      ug = "echo ungrouped"
+      [test]
+      ef = "echo Foo"
+      eb = "echo Bar"
+      """
+    When I run `fav -ls`
+    Then it should pass with exactly:
+      """
+      ug = "echo ungrouped"
+      [test]
+      ef = "echo Foo"
+      eb = "echo Bar"
+
+      """

data/features/step_definitions/command-line-favs_steps.rb

@@ -0,0 +1,25 @@
+require 'parseconfig'
+
+Then(/^the ungrouped command "(.*?)" is added with name "(.*?)"$/) do |command, name|
+	config = ParseConfig.new("#{ENV['HOME']}/.favs")
+	expect(config[name]).to eq(command)
+end
+
+Then(/^the command "(.*?)" is added with name "(.*?)" to the group "(.*?)"$/) do |command, name, group|
+  config = ParseConfig.new("#{ENV['HOME']}/.favs")
+  expect(config[group][name]).to eq(command)
+end
+
+Then(/^the file "(.*?)" exists in "(.*?)"$/) do |file_name, dir|
+  	expect(File.exist?("#{dir}/#{file_name}")).to be true
+end
+
+Then(/^the command with name "(.*?)" no longer exists as a fav in the group "(.*?)"$/) do |name, group|
+  config = ParseConfig.new("#{ENV['HOME']}/.favs")
+  expect(config[group][name]).to be_nil
+end
+
+Then(/^the command with name "(.*?)" no longer exists as a fav$/) do |name|
+  config = ParseConfig.new("#{ENV['HOME']}/.favs")
+  expect(config[name]).to be_nil
+end

data/features/support/env.rb

@@ -0,0 +1,22 @@
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+
+  @original_home = ENV['HOME']
+  ENV['HOME'] = "/tmp/home"
+  FileUtils.rm_rf "/tmp/home"
+  FileUtils.mkdir "/tmp/home"
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+  ENV['HOME'] = @original_home
+end

data/lib/fav/version.rb

@@ -0,0 +1,3 @@
+module Fav
+  VERSION = "0.0.1"
+end

data/lib/fav.rb

@@ -0,0 +1,179 @@
+require "fav/version"
+require 'methadone'
+require 'parseconfig'
+require "highline/import"
+
+module Fav
+
+  # A Factory to Create Commands.
+  #
+  # The type of command that is created is based on the "action" cli option passed in;
+  # These include: Add (-a), Remove (-r), List (-ls). The default action is the Run Command.
+  class CommandFactory
+    # Static Factory Method
+    def self.makeCommand(cli_options, command_name, command_args)
+      if cli_options[:add]
+        command_name_check(command_name, 'adding')
+        AddCommand.new(cli_options, command_name, command_args, {bypass_group_check: true})
+      elsif cli_options[:remove]
+        command_name_check(command_name, 'removing')
+        RemoveCommand.new(cli_options, command_name, command_args)
+      elsif cli_options [:list]
+        ListCommand.new(cli_options, command_name, command_args)
+      else
+        RunCommand.new(cli_options, command_name, command_args)
+      end
+    end
+
+    # Checks that command name is given, if it is not raise an exception
+    def self.command_name_check(command_name, operation)
+      raise "Must specify command name when #{operation} a fav." unless command_name
+    end
+  end
+
+  # Base class for all commands
+  class FavCommand
+    include Methadone::CLILogging
+    include Methadone::SH
+
+    attr_reader :favs_file, :config, :cli_options, :command_name, :command_args, :command_options
+
+    def initialize(cli_options, command_name, command_args, command_options={})
+      @favs_file = "#{ENV['HOME']}/.favs"
+      # if ~/.favs file does not exist, create it
+      FileUtils.touch self.favs_file unless File.exist?(self.favs_file)
+
+      # parse ~/.favs
+      @config = ParseConfig.new(self.favs_file)
+
+      @cli_options = cli_options
+      @command_name = command_name
+      @command_args = command_args
+      @command_options = command_options
+    end
+
+    # Run the Command!
+    def run!
+      # specify callbacks for when the command is grouped or ungrouped
+      if self.cli_options[:group]
+        #raise error if group doesn't exist, unless bypass is specified
+        raise "Specified group does not exist." unless self.config[self.cli_options[:group]] || self.command_options[:bypass_group_check]
+        on_group(self.cli_options[:group])
+      else
+        on_non_group
+      end
+      post_group
+    end
+
+    # A hook called after the "grouping" method
+    def post_group
+    end
+  end
+
+  # Run a command specified as a Fav.
+  class RunCommand < FavCommand
+    # Run grouped command
+    def on_group(group)
+      # If we are running a grouped command, we must check if we are running the entire group or an individual command within a group.
+      if self.command_name
+        run_cmd self.config[group][self.command_name]
+      else
+        input = self.cli_options[:no_prompt] ? 'C' : 'N'
+        self.config[group].each do |key, value|
+          # don't re-prompt if they have chosen to continue
+          input = ask "Run command: #{value}? [(Y)es, (N)o, (C)ontinue, (B)reak]" unless input == 'C'
+          case input
+          when 'Y', 'C'
+            sh value
+          when 'B'
+            puts 'Breaking the execution of all remaining commands in group.'
+            break
+          else #'N' or some unrecognized option
+            puts "Skipping the execution of #{value}"
+          end
+        end
+      end
+    end
+
+    # Run non-grouped command
+    def on_non_group
+      run_cmd self.config[self.command_name]
+    end
+
+    private
+    def run_cmd(cmd)
+      unless cmd
+        error "Command does not exist"
+        return
+      end
+      cmd = cmd.gsub(/\$\d+/) do |d|
+        cmd_arg = command_args[d[1..-1].to_i]
+        error "Missing command argument at position #{d[1..-1]}" unless cmd_arg
+        cmd_arg
+      end
+      sh cmd
+    end
+  end
+
+  # A command to list commands
+  class ListCommand < FavCommand
+    # List commands in the group
+    def on_group(group)
+      self.config[group].each { |cmd_name, cmd_value| print_command(cmd_name, cmd_value) }
+    end
+
+    # List all commands
+    def on_non_group
+      file = File.open(self.favs_file, "rb")
+      puts file.read
+    end
+
+    private
+    # Print command name/value to console
+    def print_command(cmd_name, cmd_val)
+      puts "#{cmd_name} = \"#{cmd_val}\""
+    end
+  end
+
+  # A command that writes back to the Favs file
+  class WritableCommand < FavCommand
+    # Write the contents after performing the command
+    def post_group
+      file = File.open("#{ENV['HOME']}/.favs", 'w')
+      self.config.write(file)
+      file.close
+    end
+  end
+
+  # A command to add a Fav
+  class AddCommand < WritableCommand
+    # Add a grouped fav
+    def on_group(group)
+      self.config.add_to_group(group, self.command_name, self.cli_options[:add])
+      puts "Successfully added #{self.command_name} to the '#{group}' group!"
+    end
+
+    # Add a non-grouped fav
+    def on_non_group
+      self.config.add(self.command_name, self.cli_options[:add])
+      puts "Successfully added #{self.command_name}"
+    end
+  end
+
+  # A command to remove a fav
+  class RemoveCommand < WritableCommand
+    # Remove a grouped fav
+    def on_group(group)
+      #raise error if command they are attempting to remove doesn't exist
+      raise "Can not remove command because it doesn't exist" unless self.config[group][self.command_name]
+      self.config[group].delete(self.command_name)
+      puts "Successfully removed #{self.command_name} from the '#{group}' group!"
+    end
+
+    # Remove a non-grouped fav
+    def on_non_group
+      self.config.params.delete(self.command_name)
+      puts "Successfully removed #{self.command_name}"
+    end
+  end
+end

data/test/tc_something.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+class TestSomething < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: command-line-favs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jon Bake
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: parseconfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Commands are stored as a Command Name to Command map within your ~/.favs
+  file and can be organized into groups.  Stored commands can then be easily ran.
+email:
+- jmb@jonbake.com
+executables:
+- fav
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- README.rdoc
+- Rakefile
+- bin/fav
+- command-line-favs.gemspec
+- features/command-line-favs.feature
+- features/step_definitions/command-line-favs_steps.rb
+- features/support/env.rb
+- lib/fav.rb
+- lib/fav/version.rb
+- test/tc_something.rb
+homepage: https://github.com/jonmbake/command-line-favs
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A CLI utility for organizing your commonly used shell commands.
+test_files:
+- features/command-line-favs.feature
+- features/step_definitions/command-line-favs_steps.rb
+- features/support/env.rb
+- test/tc_something.rb