clue 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: adc1f6e8d6b476ddecc339386015e71bab4d4c0d
+  data.tar.gz: 2f5bd6a517174c7c8cc43d2e332b19b37810ca16
+SHA512:
+  metadata.gz: 24232473b4740567d10ec39695048b28b4361d5842ecdb31e2228bdca093d51ef184621d2f43f43c2429f93960b5fa585f48aa9d3129d9759964cbe0ed16b239
+  data.tar.gz: dae14fdd4fe484416e2c5991428ebe8208d24cdcc65bf73b9ab86d333d886003f58493ff926e16c50fb3dbf47b80da5bb86560c72925a5563c81c867a211e5d7

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.8.7
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    clue (1.0.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    diff-lcs (1.2.1)
+    i18n (0.6.1)
+    multi_json (1.7.1)
+    rake (10.0.3)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  clue!
+  rake
+  rspec

data/LICENCE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Novelys
+
+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,79 @@
+# Clue
+
+Clue is an oriented-object wrapper around command line utilities.
+It allows you to execute complex shell commands without the harass of building the string manually.
+The use-case in mind when creating this gem was rake tasks/capistrano recipes involving third party tools.
+
+## Prerequisites
+
+This gem depends only on activesupport. It is tested agains many rubies: 1.8.7, 1.9.3, 2.0.0, jruby-18, jruby-19, rubinius-18, rubinius-19, thanks to travis-ci.
+
+While it is tested against Ruby 1.8, we do not garanty support in future releases, as it is approaching end of life.
+
+## Installation
+
+Directly : `gem install clue`
+
+Gemfile : `gem 'clue'`
+
+## Usage
+
+There is only one class, `Clue`. First, instantiate the object, then invoke `call` without arguments on it. In most cases, the only difference of usage will be the options passed to the constructor, though you can set them later.
+
+### Example
+
+```ruby
+clue = Clue.new 'mytool', :options => [:drop, {:depth => 1}], :arguments => '~/.hidden', :stdout => '~/not_hidden'
+clue.call
+
+# Will execute:
+# mytool --depth '1' --drop ~/.hidden > '~/not_hidden'
+```
+
+### Command name
+
+The command name can be supplied when initializing the object, as done above, or at a later point, by setting `command` to some value.
+Calling `call` will raise an exception if `command` is not present.
+
+### Options
+
+`Clue` accepts options when initializing, as in `clue = Clue.new(options: [:first, :second, {third: :value}])`.
+
+You must supply "singular" (options without value) first, and "valued" options as a trailing hash, as shown above.  
+You can add options at a later point use `add_singular_option`, `add_singular_options`, `add_option`, and `add_options`.
+
+### Arguments
+
+`Clue` accepts arguments when initializing, as in `clue = Clue.new(arguments: 'path/to/file')`.
+While in most of the case a single argument will be passed, you can pass an array as well.
+
+### Streams
+
+`Clue` handles `stdin`, `stdout`, and `stderr` when initializing, as in `clue = Clue.new(stdout: 'path/to/file')`. Only strings will be recognized.
+
+### Verbose/dry-run
+
+Clue can run in `verbose` or `dry_run` mode. The first prints the command before running, the latter only prints it.
+You can activate those modes when initializing, by supplying `verbose: true` or `dry_run: true`, or by setting the values at a later point.
+Both of them are false by default.
+
+### Hooks
+
+There is two type of hooks, running at two points: `before`/`after` `initialize`/`call`. They allow you to print extra data or to execute specific manipulation when subclassing `Clue`.
+
+One use case is in `novelys/gomon`, where `after_initialize` is used to parse & split the `uri` option, and `before/after_call` are used to inform of what is happening.
+
+## Validations
+
+There is no mecanisme built-in for validating the presence/format of arguments, as we feel there is not a great need for it. However, if you come with an elegant and tested solution, we'll consider merging it.
+
+## Contributions
+
+1. Check for open issues or open a fresh issue to start a discussion around a feature idea or a bug. In the first case, please include a use-case.
+2. Fork the repository on Github, make a feature branch, work on this branch.
+3. If necessary, write a test which shows that the bug was fixed or that the feature works as expected.
+4. Send a pull request and annoy us until we notice it. :)
+
+## Changelog
+
+* `1.0.0`: First version.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake'
+
+begin
+  require 'bundler/setup'
+  Bundler::GemHelper.install_tasks
+rescue LoadError
+  puts 'although not required, bundler is recommened for running the tests'
+end
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--color", '--format doc']
+end

data/clue.gemspec

@@ -0,0 +1,21 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'clue/version'
+
+Gem::Specification.new do |s|
+  s.name                      = "clue"
+  s.version                   = Clue::VERSION
+  s.platform                  = Gem::Platform::RUBY
+  s.authors                   = ["Kevin Soltysiak"]
+  s.email                     = ["contact@novelys.com"]
+  s.homepage                  = "http://github.com/novelys/clue"
+  s.summary                   = "Ruby OO Layer around cli tools"
+  s.description               = "Ease up interactions with CLI tools by wrapping them in objects"
+  s.rubyforge_project         = s.name
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files                     = `git ls-files`.split("\n")
+  s.require_path              = 'lib'
+
+  s.add_dependency('activesupport')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec')
+end

data/lib/clue.rb

@@ -0,0 +1,32 @@
+class Clue; end
+
+require 'clue/arguments'
+require 'clue/cli'
+require 'clue/options'
+require 'clue/streams'
+require 'clue/version'
+
+class Clue
+  include Arguments
+  include CLI
+  include Options
+  include Streams
+
+  # Store command name, parse & store args
+  def initialize(*args)
+    hsh = args.last.kind_of?(Hash) && args.pop || {}
+    raise ArgumentError, 'there should be at most one command' unless args.size <= 1
+    self.command = args.pop
+
+    before_initialize(command, hsh) if self.respond_to?(:before_initialize)
+
+    self.verbose = hsh.delete(:verbose)
+    self.dry_run = hsh.delete(:dry_run)
+
+    init_options hsh[:options]
+    init_arguments hsh[:arguments]
+    init_streams hsh
+
+    after_initialize(command, hsh) if self.respond_to?(:after_initialize)
+  end
+end

data/lib/clue/arguments.rb

@@ -0,0 +1,41 @@
+module Clue::Arguments
+  attr_reader :arguments
+
+  # Initialize arguments ivars
+  def init_arguments(args = nil)
+    @arguments = []
+
+    parse_arguments(args)
+  end
+
+  # Parse "classic" arguments
+  def parse_arguments(value = [])
+    return unless value
+
+    if value.kind_of?(String) || value.kind_of?(Symbol)
+      value = [value]
+    end
+
+    @arguments = value 
+  end
+
+  # Add one argument
+  def add_argument(arg)
+    @arguments << arg
+    @arguments.uniq!
+  end
+
+  # Add many arguemnts
+  def add_arguments(args)
+    return unless args
+    args = args.split(' ') if args.is_a?(String)
+
+    @arguments += args.map(&:to_s)
+    @arguments.uniq!
+  end
+
+  # Returns a string or arguments suitable for cli use
+  def cli_arguments
+    @arguments.join(' ')
+  end
+end

data/lib/clue/cli.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/enumerable'
+
+module Clue::CLI
+  attr_accessor :command
+
+  # Verbose, dry run readers & aliases
+  attr_reader :verbose, :dry_run
+
+  alias :dry_run? :dry_run
+  alias :verbose? :verbose
+
+  # Set the tool as verbose
+  def verbose=(input)
+    @verbose = !!input
+  end
+
+  # Set the tool as dry running
+  def dry_run=(input)
+    @dry_run = !!input
+  end
+
+  # Command as an array
+  def cli_command_array
+    [@command, cli_options, cli_arguments, cli_streams].each_with_object([]) do |string, memo|
+      memo << string if string && string != ''
+    end
+  end
+
+  # Command as a string
+  def cli_command
+    cli_command_array.join(' ')
+  end
+
+  # Print command
+  def print
+    puts cli_command
+  end
+
+  # Print and/or execute command
+  def call
+    raise ArgumentError, 'a command is expected' unless @command
+
+    before_call if self.respond_to?(:before_call)
+
+    print if dry_run? || verbose?
+    system(cli_command) unless dry_run?
+
+    after_call if self.respond_to?(:after_call)
+  end
+end

data/lib/clue/options.rb

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/enumerable'
+
+module Clue::Options
+  attr_reader :options, :singular_options
+
+  # Initialize options ivars
+  def init_options(options = nil)
+    @options = {}
+    @singular_options = []
+
+    parse_options(options) if options
+  end
+
+  # Separate simple options from valued ones.
+  def parse_options(options)
+    if options.kind_of?(Hash)
+      @options = options
+    elsif options.kind_of?(Array)
+      @singular_options = options
+      @options = @singular_options.pop if @singular_options.last.kind_of?(Hash)    
+    elsif options.kind_of?(String) || options.kind_of?(Symbol)
+      @singular_options = [options.to_sym]
+    end
+  end
+
+  # Add a singular option
+  def add_singular_option(option)
+    @singular_options << option.to_s
+    @singular_options.uniq!
+  end
+
+  # Add many singular options
+  def add_singular_options(options)
+    return unless options
+    options = options.split(' ') if options.is_a?(String)
+
+    @singular_options += options.map(&:to_s)
+    @singular_options.uniq!
+  end
+
+  # Add a single options
+  def add_option(key, value)
+    @options[key.to_sym] = value.to_s
+  end
+
+  # Add many options
+  def add_options(opts = {})
+    opts.each { |key, value| add_option key, value }
+  end
+
+  # Returns the options string
+  def cli_options
+    options_as_array.join(' ')
+  end
+
+  # Returns options as an array
+  def options_as_array
+    # Valued options
+    ary = @options.each_with_object([]) do |(key, value), memo|
+      memo << "--#{key.to_s} '#{value.to_s}'"
+    end
+
+    # Singular options
+    ary = @singular_options.each_with_object(ary) do |opt, memo|
+      memo << "--#{opt.to_s}"
+    end
+
+    ary
+  end
+end

data/lib/clue/streams.rb

@@ -0,0 +1,40 @@
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash/slice'
+
+module Clue::Streams
+  STREAMS_SYMBOLS = {
+    :stdin  => '<',
+    :stdout => '>',
+    :stderr => '2>'
+  }
+  RECOGNIZED_STREAMS = STREAMS_SYMBOLS.keys
+
+  attr_reader :stdin, :stdout, :stderr
+
+  # Initialize streams ivars
+  def init_streams(args = nil)
+    set_streams(args.slice(*RECOGNIZED_STREAMS)) if args
+  end
+
+  # set a stream
+  def set_stream(stream, value)
+    instance_variable_set "@#{stream.to_s}", value
+  end
+
+  # Add many arguemnts
+  def set_streams(streams)
+    return unless streams && streams.kind_of?(Hash)
+
+    streams.each { |stream, value| set_stream stream, value }
+  end
+
+  # Returns a string of streams suitable for cli use
+  def cli_streams
+    ary = STREAMS_SYMBOLS.each_with_object([]) do |(key, value), memo|
+      ivar = instance_variable_get "@#{key}"
+      memo << "#{value} '#{ivar}'" if ivar
+    end
+
+    ary.join(' ')
+  end
+end

data/lib/clue/version.rb

@@ -0,0 +1,3 @@
+class Clue
+  VERSION = '1.0.0'
+end

data/spec/arguments_spec.rb

@@ -0,0 +1,60 @@
+require 'clue'
+
+describe "Arguments" do
+  subject { Clue.new 'commandname'}
+  let(:arguments) { subject.instance_variable_get :@arguments }
+
+  it 'should add one argument' do
+    subject.add_argument 'value'
+    expect(arguments).to include 'value'
+  end
+
+  it 'should add several arguments' do
+    subject.add_arguments 'rocky balboa'
+    expect(arguments).to include 'rocky', 'balboa'
+  end
+
+  it 'should add several arguments given as string' do
+    subject.add_arguments 'rocky balboa'
+    expect(arguments).to include 'rocky', 'balboa'
+  end
+
+  it 'should add several arguments given as array' do
+    subject.add_arguments ['rocky', 'balboa']
+    expect(arguments).to include 'rocky', 'balboa'
+  end
+
+  it 'should not add many times the same argument' do
+    subject.add_arguments ['rocky', 'rocky']
+    expect(arguments).to include 'rocky'
+    expect(arguments.size).to eq 1
+  end
+
+  it 'can merge arguments into a string' do
+    subject.add_arguments %w(john jim jones)
+    
+    expect(subject.cli_arguments).to include "john"
+    expect(subject.cli_arguments).to include "jim"
+    expect(subject.cli_arguments).to include "jones"
+  end
+
+  it 'should recognize one argument given during initialization' do
+    clue = Clue.new 'commandname', :arguments => 'john'
+    args = clue.instance_variable_get :@arguments
+    expect(args).to include 'john'
+  end
+
+  it 'should recognize many arguments given during initialization' do
+    clue = Clue.new 'commandname', :arguments => ['john', 'mcclane']
+    args = clue.instance_variable_get :@arguments
+    expect(args).to include 'john'
+    expect(args).to include 'mcclane'
+  end
+
+  it 'can merge arguments into a string' do
+    subject.add_arguments %w(john jim)
+    
+    expect(subject.cli_arguments).to include "john"
+    expect(subject.cli_arguments).to include "jim"
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,61 @@
+require 'clue'
+
+describe "CLI" do
+  subject { Clue.new 'commandname'}
+
+  it 'should not raise an error when given one argument or none' do
+    p = Proc.new { Clue.new 'john' }
+    expect(p).not_to raise_error
+
+    p = Proc.new { Clue.new }
+    expect(p).not_to raise_error
+  end
+
+  it 'should raise an error when more than one argument' do
+    p = Proc.new { Clue.new 'john', 'doe' }
+    expect(p).to raise_error ArgumentError
+  end
+
+  it 'should accept options' do
+    p = Proc.new { Clue.new 'john', :wayne => 'lala' }
+    expect(p).not_to raise_error
+  end
+
+  it 'should recognize "verbose" option' do
+    c = Clue.new 'john', :verbose => true
+    expect(c.verbose).to be_true
+
+    c = Clue.new 'john', :verbose => 'something truthy'
+    expect(c.verbose).to be_true
+  end
+
+  it 'should not be "verbose" by default' do
+    c = Clue.new 'john'
+    expect(c.verbose).to be_false
+  end
+
+  it 'should recognize "dry run" option' do
+    c = Clue.new 'john', :dry_run => true
+    expect(c.dry_run).to be_true
+
+    c = Clue.new 'john', :dry_run => 'something truthy'
+    expect(c.dry_run).to be_true
+  end
+
+  it 'should not be a "dry run" by default' do
+    c = Clue.new 'john'
+    expect(c.dry_run).to be_false
+  end
+
+  it 'should have a command string' do
+    clue = Clue.new 'commandname', :options => [:drop, {:depth => 1}], :arguments => '~/.hidden', :stdout => '~/not_hidden'
+    
+    expect(clue.cli_command).to include clue.cli_options
+    expect(clue.cli_command).to include clue.cli_arguments
+    expect(clue.cli_command).to include clue.cli_streams
+  end
+
+  it 'should raise an exception when called without a command name' do
+    expect(Clue.new).to raise_error ArgumentError
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,71 @@
+require 'clue'
+
+describe "Options" do
+  subject { Clue.new 'commandname'}
+  let(:options) { subject.instance_variable_get :@options }
+  let(:singular) { subject.instance_variable_get :@singular_options }
+
+  it 'should add one option' do
+    subject.add_option :key, 'value'
+    expect(options[:key]).to eq 'value'
+  end
+
+  it 'should add several options' do
+    subject.add_options :key1 => 'value1', :key2 => 'value2'
+    expect(options[:key1]).to eq 'value1'
+    expect(options[:key2]).to eq 'value2'
+  end
+
+  it 'should add options with symbols as keys' do
+    subject.add_options 'key' => 'value'
+    expect(options[:key]).to eq 'value'
+  end
+
+  it 'should add one singular option' do
+    subject.add_singular_option 'hank'
+    expect(singular).to include 'hank'
+  end
+
+  it 'should add several singular options given as string' do
+    subject.add_singular_options 'rocky balboa'
+    expect(singular).to include 'rocky', 'balboa'
+  end
+
+  it 'should add several singular options given as array' do
+    subject.add_singular_options ['rocky', 'balboa']
+    expect(singular).to include 'rocky', 'balboa'
+  end
+
+  it 'can override previous keys' do
+    subject.add_option :key, 'value'
+    expect(options[:key]).to eq 'value'
+    subject.add_option :key, 'new_value'
+    expect(options[:key]).to eq 'new_value'
+  end
+
+  it 'should not add many times the same singular option' do
+    subject.add_singular_options ['rocky', 'rocky']
+    expect(singular).to include 'rocky'
+    expect(singular.size).to eq 1
+  end
+
+  it 'can merge options into a string' do
+    subject.add_options :key1 => 'value1', :key2 => 'value2'
+    subject.add_singular_options %w(john jim jones)
+    
+    expect(subject.cli_options).to include "--key1 'value1'"
+    expect(subject.cli_options).to include "--key2 'value2'"
+    expect(subject.cli_options).to include "--john"
+    expect(subject.cli_options).to include "--jim"
+    expect(subject.cli_options).to include "--jones"
+  end
+
+  it 'should recognize options given during initialization' do
+    clue = Clue.new 'commandname', :options => ['john', 'mcclane', {:is => 'a killer'}]
+    opts = clue.instance_variable_get :@options
+    sing = clue.instance_variable_get :@singular_options
+    expect(opts[:is]).to eq 'a killer'
+    expect(sing).to include 'john'
+    expect(sing).to include 'mcclane'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/streams_spec.rb

@@ -0,0 +1,46 @@
+require 'clue'
+
+describe "Streams" do
+  subject { Clue.new 'commandname'}
+
+  let(:stdin)  { subject.stdin }
+  let(:stdout) { subject.stdout }
+  let(:stderr) { subject.stderr }
+
+  it 'should set stdin' do
+    subject.set_stream :stdin, 'value'
+    expect(stdin).to eq 'value'
+  end
+
+  it 'should set stdout' do
+    subject.set_stream :stdout, 'value'
+    expect(stdout).to eq 'value'
+  end
+
+  it 'should set stderr' do
+    subject.set_stream :stderr, 'value'
+    expect(stderr).to eq 'value'
+  end
+
+  it 'should add several streams' do
+    subject.set_streams :stdin => 'value', :stdout => 'value2', :stderr => 'val3'
+    expect(stdin).to eq 'value'
+    expect(stdout).to eq 'value2'
+    expect(stderr).to eq 'val3'
+  end
+
+  it 'should recognize streams given during initialization' do
+    clue = Clue.new 'commandname', :stdin => 'john', :stderr => 'james', :stdout => 'jim'
+    expect(clue.stdin).to eq 'john'
+    expect(clue.stdout).to eq 'jim'
+    expect(clue.stderr).to eq 'james'
+  end
+
+  it 'can merge streams into a string' do
+    subject.set_streams :stdin => 'value', :stdout => 'value2', :stderr => 'val3'
+    
+    expect(subject.cli_streams).to include "> 'value2'"
+    expect(subject.cli_streams).to include "< 'value'"
+    expect(subject.cli_streams).to include "2> 'val3'"
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: clue
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kevin Soltysiak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ease up interactions with CLI tools by wrapping them in objects
+email:
+- contact@novelys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENCE.md
+- README.md
+- Rakefile
+- clue.gemspec
+- lib/clue.rb
+- lib/clue/arguments.rb
+- lib/clue/cli.rb
+- lib/clue/options.rb
+- lib/clue/streams.rb
+- lib/clue/version.rb
+- spec/arguments_spec.rb
+- spec/cli_spec.rb
+- spec/options_spec.rb
+- spec/spec_helper.rb
+- spec/streams_spec.rb
+homepage: http://github.com/novelys/clue
+licenses: []
+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: 1.3.6
+requirements: []
+rubyforge_project: clue
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby OO Layer around cli tools
+test_files: []