tartlet 0.0.1

data/.gitignore

@@ -0,0 +1,29 @@
+results.html
+pkg
+html
+
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+## generic files to ignore
+*~
+*.lock
+*.DS_Store
+*.swp
+*.out

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jake M
+
+MIT License
+
+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,114 @@
+# Tartlet
+
+A wrapper for tar that provides sensible defaults
+
+## Description
+
+Tar horror stories. Everyone has one. You used the wrong flags and accidentally
+overwrote one of your source files without a backup. Or you extracted a tarball
+over your current directory and deleted half the updates to your project. You
+spent 30 minutes scouring Google for the right set of flags to extract a zipped
+tarball instead of an unzipped one. Why are there so many flags!?!
+
+Enter Tartlet. Tartlet is a small commandline wrapper around tar that handles
+the obnoxious flags for you. Need to extract an archive?
+
+    tartlet extract thinmints.tar.gz
+
+Mmmmmmm. Delicious extracted cookies. Need to compress a set of files?
+
+    tartlet compress butter sugar flour --output cookie
+
+Mmmmmmmmm. Chocolaty compressed cookies. Tartlet makes it easy to make archives
+(and apparently I'm craving cookies- please hold).
+
+## Installation
+
+
+Install via gem as:
+
+    $ gem install tart
+
+## Usage
+
+Tartlet takes a command and then a list of files, with optional flags thrown
+anywhere.
+
+### Commands
+
+* `compress` - takes a list of files, and by default compresses them into
+gzipped tarball `archive.tar.gz`
+
+    ex:
+
+        $ tartlet compress foo bar baz
+
+    ***TODO***: do a clobbering check before making the tarball to ensure file
+	            safety
+
+* `extract` - takes a single zipped tarball and extracts it into the current
+directory
+
+    ex:
+
+        $ tartlet extract archive.tar.gz
+
+    ***TODO***: take a list of tarballs and extract them each into their own
+	            folder
+
+    ***TODO***: do a clobbering check before extracting the tarball to ensure
+	            file safety
+
+### Options
+
+Options can be placed anywhere in the command, eg. `tartlet -d compress -o
+target file1 file2` is the same as `tartlet compress file1 file2 -d -o target`
+which is the same as `tartlet compress -d file1 -o target file2`. I prefer to
+put -d before the command, -t after the command but before the files, and -o at
+the very end, but put them in whatever order makes sense to you.
+
+* `-o VALUE`, `--output VALUE` - instead of using the default output
+(archive.tar.gz or the current directory), direct output to **VALUE**. For
+compression archive name, tartlet will automatically append the proper file
+suffix (.tar or .tar.gz) if it is not already provided.
+
+    ex:
+
+        # extract contents of archive into folder 'dirname'
+        $ tartlet extract archive.tar.gz -o dirname
+
+        # compress list of files into tarball 'files.tar.gz'
+        $ tartlet compress foo bar baz -o files.tar.gz
+        -- or --
+        $ tartlet compress foo bar baz -o files
+
+* `--tarball`, `-tar`, or `-t` - treat tarball as not-gzipped, e.g.
+`archive.tar` (vs the default assumption of a gzipped tarball, eg
+`archive.tar.gz`)
+
+    ex:
+
+        # extract contents of archive into current directory
+        $ tartlet extract --tarball archive.tar
+
+        # compress files into non-zipped tarball
+        $ tartlet compress --tarball foo bar baz
+
+* `--dry-run`, `--dry`, `-d` - don't execute any commands, simply print to
+stdout the tar command that would be produced by tartlet
+
+    ex:
+
+        $ tartlet --dry compress foo bar baz --tarball -o files
+        tar -cf files.tar foo bar baz
+
+        $ tartlet extract --dry-run lotsoffiles.tar.gz -o safefolder
+        tar -xzf lotsoffiles.tar.gz -C safefolder
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/README.rdoc

@@ -0,0 +1,115 @@
+= tartlet - a wrapper for tar that provides sensible defaults
+
+Author::  Jacob Maskiewicz (jakemaskiewicz@gmail.com)
+Copyright:: Copyright (c) 2013 Jacob Maskiewicz
+
+
+== Description
+
+Tar horror stories. Everyone has one. You used the wrong flags and accidentally
+overwrote one of your source files without a backup. Or you extracted a tarball
+over your current directory and deleted half the updates to your project. You
+spent 30 minutes scouring Google for the right set of flags to extract a zipped
+tarball instead of an unzipped one. Why are there so many flags!?!
+
+Enter Tartlet. Tartlet is a small commandline wrapper around tar that handles
+the obnoxious flags for you. Need to extract an archive?
+
+    tartlet extract thinmints.tar.gz
+
+Mmmmmmm. Delicious extracted cookies. Need to compress a set of files?
+
+    tartlet compress butter sugar flour --output cookie
+
+Mmmmmmmmm. Chocolaty compressed cookies. Tartlet makes it easy to make archives
+(and apparently I'm craving cookies- please hold).
+
+== Installation
+
+
+Install via gem as:
+
+    $ gem install tart
+
+== Usage
+
+Tartlet takes a command and then a list of files, with optional flags thrown
+anywhere.
+
+=== Commands
+
+* <tt>compress</tt> - takes a list of files, and by default compresses them into gzipped tarball <tt>archive.tar.gz</tt>
+
+ex:
+
+	$ tartlet compress foo bar baz
+
+***TODO***: do a clobbering check before making the tarball to ensure file
+			safety
+
+* <tt>extract</tt> - takes a single zipped tarball and extracts it into the current directory
+
+ex:
+
+	$ tartlet extract archive.tar.gz
+
+***TODO***: take a list of tarballs and extract them each into their own
+			folder
+
+***TODO***: do a clobbering check before extracting the tarball to ensure
+			file safety
+
+=== Options
+
+Options can be placed anywhere in the command, eg. <tt>tartlet -d compress -o
+target file1 file2</tt> is the same as <tt>tartlet compress file1 file2 -d -o target</tt>
+which is the same as <tt>tartlet compress -d file1 -o target file2</tt>. I prefer to
+put -d before the command, -t after the command but before the files, and -o at
+the very end, but put them in whatever order makes sense to you.
+
+* <tt>-o VALUE</tt>, <tt>--output VALUE</tt> - instead of using the default output (archive.tar.gz or the current directory), direct output to **VALUE**. For compression archive name, tartlet will automatically append the proper file suffix (.tar or .tar.gz) if it is not already provided.
+
+ex:
+
+	# extract contents of archive into folder 'dirname'
+	$ tartlet extract archive.tar.gz -o dirname
+
+	# compress list of files into tarball 'files.tar.gz'
+	$ tartlet compress foo bar baz -o files.tar.gz
+	-- or --
+	$ tartlet compress foo bar baz -o files
+
+* <tt>--tarball</tt>, <tt>-tar</tt>, or <tt>-t</tt> - treat tarball as not-gzipped, e.g. <tt>archive.tar</tt> (vs the default assumption of a gzipped tarball, eg <tt>archive.tar.gz</tt>)
+
+ex:
+
+	# extract contents of archive into current directory
+	$ tartlet extract --tarball archive.tar
+
+	# compress files into non-zipped tarball
+	$ tartlet compress --tarball foo bar baz
+
+* <tt>--dry-run</tt>, <tt>--dry</tt>, <tt>-d</tt> - don't execute any commands, simply print to stdout the tar command that would be produced by tartlet
+
+ex:
+
+	$ tartlet --dry compress foo bar baz --tarball -o files
+	tar -cf files.tar foo bar baz
+
+	$ tartlet extract --dry-run lotsoffiles.tar.gz -o safefolder
+	tar -xzf lotsoffiles.tar.gz -C safefolder
+
+
+
+== Links
+
+* {Source on Github}[https://github.com/jakemask/tartlet]
+* RDoc[LINK TO RDOC.INFO]
+
+== Contributing
+
+1. Fork the {Github Source}[https://github.com/jakemask/tartlet]
+2. Create your feature branch (<tt>git checkout -b my-new-feature</tt>)
+3. Commit your changes (<tt>git commit -am 'Added some feature'</tt>)
+4. Push to the branch (<tt>git push origin my-new-feature</tt>)
+5. Create new Pull Request

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/tartlet

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'methadone'
+require 'tartlet.rb'
+
+class App
+  include Methadone::Main
+  include Methadone::CLILogging
+  include Methadone::SH
+
+  COMMANDS = %w(compress extract)
+
+  main do |command, *files| # Add args you want: |like,so|
+
+    ##
+    # Begin Execution
+    case command
+
+    ## Compress the list of files into the outfile
+    when "compress"
+      
+      # When compressing, the -o option changed where the tarball goes
+      outfile = options['output'].nil? ? Tartlet::OUTFILE : options['output']
+      
+      # Get the tar command
+      cmd = Tartlet::compressSingle(files,!options['tarball'],outfile)
+
+      # Either output or run the command
+      if options['dry'] then puts cmd else sh cmd end
+
+    ## Extract the tarballs into their respective folders
+    when "extract"
+
+      # If we have several files, we need several tar commands (later)
+      if files.length > 1
+        
+        # TODO allow for multiple files
+        help_now!("One file at a time, bub!")
+
+      else
+
+        # Simply extract the only file in the current directory
+        target = options['output'].nil? ? Tartlet::TARGET : options['output']
+
+        # Get the tar command
+        cmd = Tartlet::extractSingle(files[0],!options['tarball'],target)
+
+        # Either output or run the command
+        if options['dry'] then puts cmd else sh cmd end
+
+      end
+    else
+      help_now!("#{command} is not a valid command. Must be one of {#{COMMANDS.join(",")}}")
+    end
+
+
+  end
+
+  # supplemental methods here
+
+  # Declare command-line interface here
+
+  # Accept flags via:
+  # on("--flag VAL","Some flag")
+  # options[flag] will contain VAL
+  #
+  # Specify switches via:
+  # on("--[no-]switch","Some switch")
+  #
+  # Or, just call OptionParser methods on opts
+  #
+  # Require an argument
+  # arg :some_arg 
+  #
+  # # Make an argument optional
+  # arg :optional_arg, :optional
+
+  version Tartlet::VERSION
+
+  description 'Wrapper for tar that provides sensible options'
+
+  on("-o VALUE","--output","Output location if different than current directory");
+  on("-t","--tar","--tarball","Do not gzip the tarball after compressing")
+  on("-d","--dry","--dry-run","Do not execute any commands, simply output the commands that would be used.")
+
+  arg :command, "Command to use (#{COMMANDS.join("|")})"
+
+  arg :files, :many, "list of files to act on"
+
+  #use_log_level_option
+
+  go!
+
+end

data/features/step_definitions/tartlet_steps.rb

@@ -0,0 +1,146 @@
+# Default list of files
+FILES = %w(foo bar baz)
+TMP = "tmp/aruba"
+
+##
+# doTarball
+#
+# takes a path to a tarball, and flags for creating said tarball. It will create
+# a tarball at the given location with files foo, bar, and baz inside.
+#
+def doTarball(tarball,zip = true)
+	
+	# Save the tarball and file list for later use
+	@tarball = tarball
+	@files = FILES
+	
+	# Think out that directory
+	tar_dir = File.dirname(tarball)
+	archive = File.basename(tarball)
+	
+	# Go to the directory and make that tarball
+	FileUtils.chdir File.join(TMP,tar_dir),:verbose => true do
+
+		# Confirm the file doesn't exist before touching
+		@files.each do |f|
+			File.exists?(f).should == false
+			FileUtils.touch f, :verbose => true
+			File.exists?(f).should == true
+		end
+
+		# Tar up dem files
+		sh "tar -c#{zip ? 'z' : ''}f #{archive} #{@files.join(' ')}";
+		File.exists?(archive).should == true
+
+		# Remove dem files
+		@files.each do |f|
+			File.exists?(f).should == true
+			FileUtils.rm f, :verbose => true
+			File.exists?(f).should == false
+		end
+	end
+  
+  File.exists?(File.join(TMP,tar_dir,archive)).should == true
+end
+
+##
+# Given 'a zipped tarball "x"'
+#
+# creates zipped tarball x with files foo, bar, and baz
+#
+Given(/^a zipped tarball "(.*?)"$/) do |tarball|
+	doTarball(tarball,true)
+end
+
+##
+# Given 'a tarball "x"'
+#
+# creates tarball x with files foo, bar, and baz
+#
+Given(/^a tarball "(.*?)"$/) do |tarball|
+	doTarball(tarball,false)	
+end
+
+##
+# Then 'the files should be extracted in the directory "x"'
+#
+# asserts that files foo, bar, and baz are present in the given directory
+#
+Then(/^the files should be extracted in the directory "(.*?)"$/) do |dir|
+
+	#go to the directory and determine that each file exists
+	Dir.chdir File.join(TMP,dir) do
+		@files.each do |file|
+			File.exist?(file).should == true
+		end
+	end
+end
+
+##
+# Given 'a list of files "x" at "y"'
+#
+# creates files from space delimited list x in directory y
+#
+Given(/^a list of files "(.*?)"$/) do |files|
+	
+	# Save dem files
+	@files = files.split(' ')
+	
+	# Go to dat folder
+	Dir.chdir TMP do
+		
+		# For each file, touch it
+		@files.each do |f|
+			File.exists?(f).should == false
+			FileUtils.touch f, :verbose => true
+			File.exists?(f).should == true
+		end
+	end
+end
+
+##
+# filesInTarball
+#
+# Determines that a tarball has @files in it when extracted with given flags.
+#
+def filesInTarball(tarball,zip=true)
+
+	#get the directory and the filename
+	tar_dir = File.dirname(tarball)
+	archive = File.basename(tarball)
+	
+	#rejoin for the real path
+	targz = File.join(tar_dir,archive)
+	
+	#dat targz should exist
+	File.exists?(File.join(TMP,targz)).should == true
+	
+	#go to the directory
+	FileUtils.chdir File.join(TMP,tar_dir), :verbose => true do
+
+    # Extract the files
+    files = `tar -t#{zip ? 'z' : ''}f #{archive}`.split("\n");
+    
+    (files.sort == @files.sort).should == true
+    
+	end
+	
+end
+
+##
+# Then 'the files should be compressed into a zipped tarball at "x"'
+#
+# Determines that the zipped tarball contains @files
+#
+Then(/^the files should be compressed into a zipped tarball at "(.*?)"$/) do |tarball|
+	filesInTarball(tarball,true)	
+end
+
+##
+# Then 'the files should be compressed into a tarball at "x"'
+#
+# Determines that the tarball contains @files
+#
+Then(/^the files should be compressed into a tarball at "(.*?)"$/) do |tarball|
+	filesInTarball(tarball,false)
+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
+  
+  @base_dir = FileUtils.pwd
+
+  FileUtils.rm_rf "tmp/aruba", :verbose => true
+  FileUtils.mkdir_p "tmp/aruba", :verbose => true
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+  FileUtils.chdir @base_dir, :verbose => true
+end

data/features/tartlet.feature

@@ -0,0 +1,39 @@
+Feature: Sane Use of tar
+  In order to compress a set of files into a tarball or extract files from a tarball
+  I want a simple command
+  So I don't have to remember tar flags
+
+  Scenario: Basic UI
+    When I get help for "tartlet"
+    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 following options should be documented:
+      |--version|
+      |--output|
+      |--tarball|
+    And the banner should document that this app's arguments are:
+      |command|which is required|
+      |files|which is many|
+
+  Scenario: Extract Zipped Tarball
+    Given a zipped tarball "archive.tar.gz"
+    When I successfully run `tartlet extract archive.tar.gz`
+    Then the files should be extracted in the directory "."
+
+  Scenario: Extract Tarball
+    Given a tarball "archive.tar"
+    When I successfully run `tartlet --tar extract archive.tar`
+    Then the files should be extracted in the directory "."
+
+  Scenario: Compress Zipped Tarball
+    Given a list of files "foo bar baz"
+    When I successfully run `tartlet compress foo bar baz`
+    Then the files should be compressed into a zipped tarball at "archive.tar.gz"
+
+  Scenario: Compress Tarball
+    Given a list of files "foo bar baz"
+    When I successfully run `tartlet --tar compress foo bar baz`
+    Then the files should be compressed into a tarball at "archive.tar"

data/lib/tartlet.rb

@@ -0,0 +1,37 @@
+require "tartlet/version"
+
+module Tartlet
+  
+  OUTFILE = "archive"
+  TARGET = "."
+
+  def Tartlet.extractSingle(file, zip = true, target = TARGET)
+
+    # Generate the command
+    command = "tar -x#{zip ? 'z' : ''}f #{file}"
+
+    # Add the new target destination
+    command += " -C #{target}" unless target == "."
+
+    # Output or Run
+    return command
+    
+  end
+
+
+  def Tartlet.compressSingle(files, zip = true, target = OUTFILE)
+    
+    # Add the .tar if it's not there
+    target += ".tar" if target[/(\.tar)(\.gz)?\z/].nil?
+
+    # Add the .gz if it's not there and we're zipping
+    target += ".gz" if target[/\.(gz)\z/].nil? and zip
+    
+    # Generate the command
+    command = "tar -c#{zip ? 'z' : ''}f #{target} #{files.join(' ')}"
+    
+    # Output or Run
+    return command
+  end
+
+end

data/lib/tartlet/version.rb

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

data/tartlet.gemspec

@@ -0,0 +1,115 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/tartlet/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jake M"]
+  gem.email         = ["jakemaskiewicz@gmail.com"]
+  gem.description   = %q{
+## Description
+
+Tar horror stories. Everyone has one. You used the wrong flags and accidentally
+overwrote one of your source files without a backup. Or you extracted a tarball
+over your current directory and deleted half the updates to your project. You
+spent 30 minutes scouring Google for the right set of flags to extract a zipped
+tarball instead of an unzipped one. Why are there so many flags!?!
+
+Enter Tartlet. Tartlet is a small commandline wrapper around tar that handles
+the obnoxious flags for you. Need to extract an archive?
+
+    tartlet extract thinmints.tar.gz
+
+Mmmmmmm. Delicious extracted cookies. Need to compress a set of files?
+
+    tartlet compress butter sugar flour --output cookie
+
+Mmmmmmmmm. Chocolaty compressed cookies. Tartlet makes it easy to make archives
+(and apparently I'm craving cookies- please hold).
+
+## Installation
+
+
+Install via gem as:
+
+    $ gem install tart
+
+## Usage
+
+Tartlet takes a command and then a list of files, with optional flags thrown
+anywhere.
+
+### Commands
+
+* `compress` - takes a list of files, and by default compresses them into
+gzipped tarball `archive.tar.gz`
+
+    ex:
+
+        $ tartlet compress foo bar baz
+
+* `extract` - takes a single zipped tarball and extracts it into the current
+directory
+
+    ex:
+
+        $ tartlet extract archive.tar.gz
+
+### Options
+
+Options can be placed anywhere in the command, eg. `tartlet -d compress -o
+target file1 file2` is the same as `tartlet compress file1 file2 -d -o target`
+which is the same as `tartlet compress -d file1 -o target file2`. I prefer to
+put -d before the command, -t after the command but before the files, and -o at
+the very end, but put them in whatever order makes sense to you.
+
+* `-o VALUE`, `--output VALUE` - instead of using the default output
+(archive.tar.gz or the current directory), direct output to **VALUE**. For
+compression archive name, tartlet will automatically append the proper file
+suffix (.tar or .tar.gz) if it is not already provided.
+
+    ex:
+
+        # extract contents of archive into folder 'dirname'
+        $ tartlet extract archive.tar.gz -o dirname
+
+        # compress list of files into tarball 'files.tar.gz'
+        $ tartlet compress foo bar baz -o files.tar.gz
+        -- or --
+        $ tartlet compress foo bar baz -o files
+
+* `--tarball`, `-tar`, or `-t` - treat tarball as not-gzipped, e.g.
+`archive.tar` (vs the default assumption of a gzipped tarball, eg
+`archive.tar.gz`)
+
+    ex:
+
+        # extract contents of archive into current directory
+        $ tartlet extract --tarball archive.tar
+
+        # compress files into non-zipped tarball
+        $ tartlet compress --tarball foo bar baz
+
+* `--dry-run`, `--dry`, `-d` - don't execute any commands, simply print to
+stdout the tar command that would be produced by tartlet
+
+    ex:
+
+        $ tartlet --dry compress foo bar baz --tarball -o files
+        tar -cf files.tar foo bar baz
+
+        $ tartlet extract --dry-run lotsoffiles.tar.gz -o safefolder
+        tar -xzf lotsoffiles.tar.gz -C safefolder
+  }
+  gem.summary       = %q{A wrapper for tar that provides sensible defaults}
+  gem.homepage      = "https://github.com/jakemask/tartlet"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "tartlet"
+  gem.require_paths = ["lib"]
+  gem.version       = Tartlet::VERSION
+  gem.add_development_dependency('rdoc')
+  gem.add_development_dependency('aruba')
+  gem.add_development_dependency('rake', '~> 0.9.2')
+  gem.add_dependency('methadone', '~> 1.2.6')
+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,164 @@
+--- !ruby/object:Gem::Specification
+name: tartlet
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jake M
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+description: ! "\n## Description\n\nTar horror stories. Everyone has one. You used
+  the wrong flags and accidentally\noverwrote one of your source files without a backup.
+  Or you extracted a tarball\nover your current directory and deleted half the updates
+  to your project. You\nspent 30 minutes scouring Google for the right set of flags
+  to extract a zipped\ntarball instead of an unzipped one. Why are there so many flags!?!\n\nEnter
+  Tartlet. Tartlet is a small commandline wrapper around tar that handles\nthe obnoxious
+  flags for you. Need to extract an archive?\n\n    tartlet extract thinmints.tar.gz\n\nMmmmmmm.
+  Delicious extracted cookies. Need to compress a set of files?\n\n    tartlet compress
+  butter sugar flour --output cookie\n\nMmmmmmmmm. Chocolaty compressed cookies. Tartlet
+  makes it easy to make archives\n(and apparently I'm craving cookies- please hold).\n\n##
+  Installation\n\n\nInstall via gem as:\n\n    $ gem install tart\n\n## Usage\n\nTartlet
+  takes a command and then a list of files, with optional flags thrown\nanywhere.\n\n###
+  Commands\n\n* `compress` - takes a list of files, and by default compresses them
+  into\ngzipped tarball `archive.tar.gz`\n\n    ex:\n\n        $ tartlet compress
+  foo bar baz\n\n* `extract` - takes a single zipped tarball and extracts it into
+  the current\ndirectory\n\n    ex:\n\n        $ tartlet extract archive.tar.gz\n\n###
+  Options\n\nOptions can be placed anywhere in the command, eg. `tartlet -d compress
+  -o\ntarget file1 file2` is the same as `tartlet compress file1 file2 -d -o target`\nwhich
+  is the same as `tartlet compress -d file1 -o target file2`. I prefer to\nput -d
+  before the command, -t after the command but before the files, and -o at\nthe very
+  end, but put them in whatever order makes sense to you.\n\n* `-o VALUE`, `--output
+  VALUE` - instead of using the default output\n(archive.tar.gz or the current directory),
+  direct output to **VALUE**. For\ncompression archive name, tartlet will automatically
+  append the proper file\nsuffix (.tar or .tar.gz) if it is not already provided.\n\n
+  \   ex:\n\n        # extract contents of archive into folder 'dirname'\n        $
+  tartlet extract archive.tar.gz -o dirname\n\n        # compress list of files into
+  tarball 'files.tar.gz'\n        $ tartlet compress foo bar baz -o files.tar.gz\n
+  \       -- or --\n        $ tartlet compress foo bar baz -o files\n\n* `--tarball`,
+  `-tar`, or `-t` - treat tarball as not-gzipped, e.g.\n`archive.tar` (vs the default
+  assumption of a gzipped tarball, eg\n`archive.tar.gz`)\n\n    ex:\n\n        # extract
+  contents of archive into current directory\n        $ tartlet extract --tarball
+  archive.tar\n\n        # compress files into non-zipped tarball\n        $ tartlet
+  compress --tarball foo bar baz\n\n* `--dry-run`, `--dry`, `-d` - don't execute any
+  commands, simply print to\nstdout the tar command that would be produced by tartlet\n\n
+  \   ex:\n\n        $ tartlet --dry compress foo bar baz --tarball -o files\n        tar
+  -cf files.tar foo bar baz\n\n        $ tartlet extract --dry-run lotsoffiles.tar.gz
+  -o safefolder\n        tar -xzf lotsoffiles.tar.gz -C safefolder\n  "
+email:
+- jakemaskiewicz@gmail.com
+executables:
+- tartlet
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- README.rdoc
+- Rakefile
+- bin/tartlet
+- features/step_definitions/tartlet_steps.rb
+- features/support/env.rb
+- features/tartlet.feature
+- lib/tartlet.rb
+- lib/tartlet/version.rb
+- tartlet.gemspec
+- test/tc_something.rb
+homepage: https://github.com/jakemask/tartlet
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A wrapper for tar that provides sensible defaults
+test_files:
+- features/step_definitions/tartlet_steps.rb
+- features/support/env.rb
+- features/tartlet.feature
+- test/tc_something.rb