bin_diesel 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

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

data/Examples/purge_files.rb

@@ -0,0 +1,85 @@
+#! /usr/bin/env ruby
+
+class PurgeableFileList
+  KNOWN_SKIPPABLES = ['.', '..']
+  attr_reader :files
+  def initialize path, age
+    @path = path
+    @age_cutoff = Time.zone.now - age.days
+    generate_file_list
+  end
+
+  private
+  def generate_file_list
+    get_all_files_in_purge_directory
+    remove_known_skippable_files
+    remove_files_too_young_to_purge
+  end
+
+  def get_all_files_in_purge_directory
+    @files = Dir.entries(@path)
+    @files.map!{|file| File.join(@path, file)}
+  end
+
+  def remove_known_skippable_files
+    @files = @files - KNOWN_SKIPPABLES
+  end
+  def remove_files_too_young_to_purge
+    @files.reject!{|file| File.mtime(file) > @age_cutoff }
+  end
+end
+
+class PurgeFiles
+  DEFAULT_DAYS_TO_KEEP = 30
+
+  opts_banner = "Usage: ./purge_report_files.rb [options]"
+  opts_description "By default, this will purge UI Report Files, though it can be\nturned on other things with the proper options."
+
+  opts_required :path_to_purge
+  opts_accessor :keep_n_days, :path_to_purge
+
+  opts_on("-k", "--keep-n-days DAYS", Integer, "Keep N days of files.", "\tDefault: --keep-n-days #{DEFAULT_DAYS_TO_KEEP}") do |days|
+    options.keep_n_days = days
+  end
+
+  opts_on("-p", "--path-to-purge PATH", "Purge files from PATH", "Required") do |path|
+    options.path_to_purge = path
+  end
+
+
+  def post_initialize
+    options.keep_n_days ||= DEFAULT_DAYS_TO_KEEP
+  end
+
+  run do
+    message "Checking for directory #{options.patth_to_purge}."
+    if directory_found?
+      message "Directory #{options.path_to_purge} found."
+      message "Getting list of files."
+      message "#{files.size} files found."
+      remove_files
+      message "Fin!"
+    end
+  end
+
+  private
+
+  def directory_found?
+    found = File.directory? path_to_purge
+    error_message "Directory '#{options.path_to_purge}'not found." unless found
+    found
+  end
+
+  def files
+    @files ||= PurgeableFileList.new(path_to_purge, keep_n_days).files
+  end
+
+  def remove_files
+    files.each do |file|
+      message "Deleting '#{file}'."
+      File.delete(file) unless options.dry_run
+    end
+  end
+end
+
+exit PurgeFiles.new(ARGV).run

data/Examples/test.rb

@@ -0,0 +1,48 @@
+#! /usr/bin/env ruby
+
+# This require allows you to load the Rails environment for use in your scripts.
+ require File.expand_path(File.join(File.dirname(__FILE__),'../config/environment.rb'))
+
+ class Test
+# We are using ActiveSupport Concern.  You'll need to do this. If you don't
+#   include the Rails environment as part of loading, you'll have to load
+#   lib/bin_diesel.rb first.
+   include BinDiesel
+
+#  Message says it all
+   def post_initialize
+     message "This runs after you initialize the your instance. Could be handy."
+     message "You don't need to provide me."
+   end
+
+# opts_banner is the standard header for how to execute your script.
+   opts_banner "Usage: ./my_parse_example.rb [options]"
+
+# opts_descriptions is the description of what this script does.
+   opts_description "By default, this will be an awesome description."
+   opts_description "You can have as many descriptions as you like,\nor add line breaks manually."
+
+# opts_on is how you specify additional options for your script
+#   You have access to 'options', which is a struct for holding your options.
+#   options.dry_run and options.verbose are provided by default, set to false.
+#   It takes the option flags, description strings, and a block. Only the first
+#     option flag is required.
+   opts_on "-p", "--pass-param PARAM", "Pass a param" do |param|
+     options.param = param
+   end
+   opts_on "-r", "--run-fast", "Something" do
+     options.fast = true
+   end
+   opts_on "-x", "marks the spot"
+
+# run is is the big deal. It is what will get run when you execute
+# your script. It evaluated in an instance context.
+   run do
+     message "I only show up if we are verbose and executing."
+     puts options
+     puts "INSERT CODE WITH SIDE EFFECTS HERE. :)"
+   end
+ end
+# Run this script ala the command line...
+# exit Test.new(ARGV).run
+# > ./bin/test -v

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2013, Andrew J Vargo
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,240 @@
+# Bin Diesel
+
+## Build Status
+
+![Build Status](https://api.travis-ci.org/dataxu/bin_diesel.png)
+
+[Brought to you by the fine folks at Travis-CI](https://travis-ci.org/dataxu/bin_diesel)
+
+## Introduction
+Bin Diesel is a utility that will allow you to create re-usable, executable scripts easier.
+
+Bin Diesel abstracts option parsing to simplify your 'bin' scripting.  It provides a number of wrapper methods for OptionParser, so I'd suggest having a look at that documentation to understand more of what this provides. [OptionParser Complete Example](http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html#label-Complete+example)
+
+## What's provided? AKA, the API
+
+It is important to note that methods are executed in the order defined.  This means you should set all options and text helpers *before* defining `run`.
+
+### Default options
+
+Using Bin Diesel, you get the following options for free:
+
+* `-d`, `--dry-run`, Run script without any real changes.  Sets `@dry_run` and `options.dry_run` to `true`. Sets --verbose by default.`
+
+The intent of `--dry-run` is to provide you with a way to run through the script and note output to verify that the script runs as intended.
+We generally use this flag on `ActiveRecord` calls.  For example:
+
+```ruby
+  # ...
+  run do
+    users = User.where(organization: Organization.where(name: 'DataXu'))
+    message "Updating #{users.count} DataXu users to be admins"
+    users.update_all(admin: true) unless options.dry_run
+  end
+  # ...
+```
+
+The first time through, users can run the script with `--dry-run` and note the number of users that would be modified.  A second run of the script without the `--dry-run` option
+will make the modifications.
+
+* `-v, --[no-]verbose, Run verbosely`
+
+* `-h, --help, Show description and options, and exit`
+
+### Attributes for your ready use
+
+* `verbose` - false by default
+
+  The built in message helpers won't print if verbose if false, saving you the hassle.
+
+```ruby
+puts 'Something' if verbose
+message "Event" # I only print if verbose is true!
+```
+
+* `options`
+
+This is a struct that allows you to access options you configure.  Options are generally defined in `opts_on` blocks.  For example:
+
+```ruby
+class SimpleScript
+  include BinDiesel
+
+  # Accepts three arguments and a block.  The signature is:
+  # opts_on [short flag], [long flag], [help text for the option]
+  opts_on '-f', '--file [FILE]', 'The file to operate on' do |file_name|
+    options.file_name = file_name
+  end
+end
+```
+
+The first two arguments define the short and long switches for the option.  The remaining N arguments are used as a description of the option (separated by newlines) displayed when the '--help' switch is provided.
+
+See [the OptionParser documentation for `#make_switch`](http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html#method-i-make_switch) for
+a description of the arguments `opts_on` accepts.  If the defined option accepts a value, the value will be passed to the block.
+
+* `dry_run` - false by default.  This is also available through `options.dry_run`.
+
+```ruby
+do_irrevocable_change unless dry_run
+```
+
+* `args`
+
+The args passed in to the run method.  You may have a required thing that isn't a `--option` you need to use.  This is generally an array that looks something like this (depending on the options supplied at the command line):
+
+```ruby
+['--file', 'file_name.txt', '--verbose', '--dry-run']
+```
+
+### Methods for your use
+
+* `opts_banner(text)`
+
+Set banner text for your script. Usually the bare usage line to show an example run.
+
+* `opts_description(text)`
+
+Longer form text explaining what your script does.
+
+* `opts_on *opts, &block`
+
+Meat and potatoes. This is what you'll use to set your own options. The examples provided or [OptionParser Complete example](http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html#label-Complete+example) will give you more of an idea of what is possible.  Also see [the OptionParser documentation for `#make_switch`](http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html#method-i-make_switch).
+
+Note the usage of `options` in the block to set values you'll use in your executing code.  Instance variables (instead of using `options`) are also acceptable.
+
+```ruby
+opts.on("-d", "--dry-run", "Run script without any real changes.", "\tSets --verbose by default.") do |dry_run|
+  options.dry_run = true
+  options.verbose = true
+end
+```
+
+* `opts_required *args`
+
+When parsing is done, `OptionParser::MissingArguement` will be raised for anything specified here that `options` does not respond to.
+
+```ruby
+opts_required :path
+# if you never set options.path, things go BOOM.
+```
+
+* `opts_accessor *args`
+
+Turns the provided args into accessors to help in your script writing.
+
+```ruby
+opts_accessor :path
+# allows
+File.open path
+# instead of
+File.open options.path
+# or
+File.open @path
+```
+
+* `dry_run?`
+
+Some sugar for checking if `dry_run` was set.
+
+```ruby
+save_records unless dry_run?
+```
+
+* `post_initialize`
+
+Provided so you don't have to overide Bin Diesel's initialize method.  It executes *after* all the parsing and what not, so you'll have access to options and the accessors.
+
+```ruby
+class SimpleExample
+  include BinDiesel
+
+  post_initialize do
+    # Set some other useful instance variables
+    @base_directory = File.dirname(__FILE__)
+  end
+end
+```
+
+* `run &block`
+
+This is the big deal of your script.  You should use this as the method that'll be called to kick off your script. We do nice things for you, like catch exceptions and exit and return 1 or return 0 if all goes well.
+
+If `run` is not implemented, the script will raise `NotImplementedError.
+
+```ruby
+run do
+  campaigns = find_campaigns(options.campaign_uids)
+  campaigns.each do |campaign|
+    campaign.update_attribute(:name, "#{campaign.name} Update Example") unless options.dry_run
+  end
+end
+```
+
+* `message(text)`
+
+puts text if `verbose` is set to `false`.  This is an extremely simple wrapper around `puts`:
+
+```ruby
+def message(text)
+  puts text if verbose
+end
+```
+
+* `info_message(text)`
+
+Like `message`, but prepends with `**`
+
+* `error_message(text)`
+
+`puts` text, no matter the setting of `verbose`. It also prepends text with "!! "
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bin_diesel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bin_diesel
+
+## Usage
+
+This is the most basic way to use Bin Diesel:
+
+```ruby
+#! /usr/bin/env ruby
+
+class MyScript
+  include BinDiesel # ahh yeah, goodies
+
+  post_initialize do
+    # Do some stuff with options before `run` is called
+  end
+
+  run do
+    # I am required and will throw and exception if not defined.
+    # This is what you should call, and should contain the main logic of your script.
+    # If there is no exception, it'll return 0, otherwise 1 for use as an exit code
+  end
+end
+
+if __FILE__ == $0  # don't run it if not called alone
+  exit MyScript.new(ARGV).run  # the 0 or 1 allows you to get a proper exit code
+end
+```
+
+See the Examples directory for more examples.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.warning = true
+end
+
+task default: :test

data/bin_diesel.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bin_diesel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bin_diesel"
+  spec.version       = BinDiesel::VERSION
+  spec.authors       = ["Andrew J Vargo", "Anthony White"]
+  spec.email         = ["avargo@dataxu.com", "awhite@dataxu.com"]
+  spec.description   = %q{Bin Diesel allows you to write scripts relying on Option Parser with DSL that eliminates the boiler plate code. Define options and run. }
+  spec.summary       = %q{Easier "bin" scripts built with Option Parser.}
+  spec.homepage      = "http://www.dataxu.com"
+  spec.license       = "New BSD License"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "debugger"
+end

data/lib/bin_diesel.rb

@@ -0,0 +1,185 @@
+require_relative "bin_diesel/version"
+require 'optparse'
+require 'ostruct'
+
+
+module BinDiesel
+  OPTS = {:banner => nil, :description => [], :user_options => [], :required_options => [], :accessible_options => []}
+  attr_reader :verbose, :options, :args, :dry_run
+
+  module ClassMethods
+    def run &block
+      define_method :run do
+        begin
+          puts "DRY RUN" if options.dry_run
+          instance_eval(&block)
+          ending = happy_ending
+        rescue Exception => e
+          error_message "FAILED: #{e.message}"
+          puts e.backtrace
+          ending = unhappy_ending
+        ensure
+          ending
+        end
+      end
+    end
+
+    def post_initialize &block
+      define_method :post_initialize do
+        instance_eval(&block)
+      end
+    end
+
+    def opts_banner text
+      OPTS[:banner] = text
+    end
+
+    def opts_description text
+      OPTS[:description] << text
+    end
+
+    def opts_on *opts, &block
+      OPTS[:user_options] << {:options => opts, :block => block }
+    end
+
+    def opts_required *args
+      OPTS[:required_options] += args
+    end
+
+    def opts_accessor *args
+      OPTS[:accessible_options] += args
+    end
+  end
+
+  module InstanceMethods
+    def initialize args=["--help"]
+      @args = args
+      @options = OpenStruct.new(:dry_run => false, :verbose => false)
+
+      begin
+        parse_options
+      rescue OptionParser::MissingArgument => e
+        error_message e.message
+        exit unhappy_ending
+      end
+
+      @verbose = @options.verbose
+      @dry_run = @options.dry_run
+
+      setup_option_accessors
+
+      begin
+        post_initialize
+      rescue Exception => e
+        error_message e.message
+        exit unhappy_ending
+      end
+    end
+
+    def dry_run?
+      @options.dry_run
+    end
+
+    def run
+      raise NotImplementedError, "#{self.class} does not implement method run. You may do this explictly, or via the class level DSL (recommended):\nrun do\n ...\nend"
+    end
+
+    def post_initialize
+      # TODO: EXPLAIN ME
+    end
+
+    def message text
+      puts text if verbose
+    end
+
+    def info_message text
+      message "** #{text}"
+    end
+
+    def error_message text
+      # Always print out error messages, regardless of verbose mode
+      puts "!! #{text}"
+    end
+
+    private
+
+    def happy_ending
+      0
+    end
+
+    def unhappy_ending
+      1
+    end
+
+    def setup_option_accessors
+      OPTS[:accessible_options].each do |opt|
+        define_singleton_method opt do
+          @options.send(opt)
+        end
+
+        define_singleton_method "#{opt}=" do |val|
+          @options.send("#{opt}=", val)
+        end
+      end
+    end
+
+    def parse_options
+      opts = OptionParser.new do |opt_parser|
+        opt_parser.banner = OPTS[:banner]
+        opt_parser.separator ""
+
+        OPTS[:description].each{|description| opt_parser.separator description }
+        opt_parser.separator ""
+
+        opt_parser.separator "Specific options:"
+        opt_parser.on("-d", "--dry-run", "Run script without any real changes.", "\tSets --verbose by default.") do |dry_run|
+          options.dry_run = true
+          options.verbose = true
+        end
+
+        opt_parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          options.verbose = v
+        end
+        opt_parser.separator ""
+
+        # USER SPECIFIED
+        OPTS[:user_options].each do |option|
+          # We allow the user to define the proc for the opts.on block via option[:block].
+          # OptionParser can get confused by the last argument (the block), and sometimes defines it twice,
+          # which blows up spectacularly with an ArgumentError
+          option[:options].reject! {|o| o.class.to_s == 'Proc'}
+
+          if option[:block]
+            opt_parser.on(*(option[:options] << Proc.new{|*args| self.instance_exec(*args, &option[:block])}))
+          else
+            opt_parser.on(*option[:options])
+          end
+        end
+        opt_parser.separator ""
+
+        opt_parser.separator "Common options:"
+        opt_parser.on_tail("-h", "--help", "Show this message") do
+          puts opt_parser
+          exit happy_ending
+        end
+      end
+
+      the_options = opts.parse! args
+
+      OPTS[:required_options].each do |required_option|
+        raise OptionParser::MissingArgument.new("#{optionize(required_option.to_s)} - Run with --help for help.") if @options.send(required_option).nil?
+      end
+
+      the_options
+    end
+
+    def optionize string
+      "--#{string.gsub('_', '-')}"
+    end
+  end
+
+  def self.included(base)
+    base.send :include, InstanceMethods
+    base.send :extend, ClassMethods
+  end
+end

data/lib/bin_diesel/version.rb

@@ -0,0 +1,3 @@
+module BinDiesel
+  VERSION = "1.0.0"
+end

data/test/lib/bin_diesel/version_test.rb

@@ -0,0 +1,7 @@
+require_relative '../../test_helper'
+
+describe BinDiesel do
+  it "must be defined" do
+    BinDiesel::VERSION.wont_be_nil
+  end
+end

data/test/lib/bin_diesel_test.rb

@@ -0,0 +1,462 @@
+require_relative '../../lib/bin_diesel'
+require_relative '../test_helper'
+
+describe BinDiesel do
+  describe "help flag" do
+    it 'is equivalent to call -h and --help' do
+      vincent = Class.new(TestDiesel)
+
+      help_output = capture_std_out do
+        swallow_exit { vincent.new(['--help']).run }
+      end
+
+      h_output = capture_std_out do
+        swallow_exit { vincent.new(['-h']).run }
+      end
+
+      help_output.must_equal(h_output)
+    end
+
+    it 'swallows other options if help is called' do
+      vincent = Class.new(TestDiesel) do
+        opts_banner "This is my banner"
+
+        opts_on '-e', '--error', 'Raise an error' do
+          options.error = "Raised error"
+        end
+
+        run do
+          puts options.error
+        end
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--error', '--help']).run }.must_output "This is my banner"
+      end
+    end
+
+    it 'raises a system exit' do
+      vincent = Class.new(TestDiesel)
+      swallow_std_out do
+        lambda{ vincent.new(["--help"]).run }.must_raise(SystemExit)
+      end
+    end
+
+    it 'is not required' do
+      vincent = Class.new(TestDiesel) do
+        opts_banner "And here is my banner"
+      end
+
+      swallow_exit do
+        lambda{ vincent.new.run }.must_output("-h, --help")
+      end
+    end
+
+    describe "opts_banner" do
+      it 'prints specified text on the first line when using a help flag' do
+        swallow_exit do
+          lambda{TestDiesel.new(["--help"]).run}.must_output("And here is my banner")
+        end
+      end
+    end
+  end
+
+  describe "opts_description" do
+    it 'prints in help text' do
+      vincent = Class.new(TestDiesel) do
+        opts_description "My description"
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--help']).run }.must_output("My description")
+      end
+    end
+
+    it 'prints after banner in help text' do
+      vincent = Class.new(TestDiesel) do
+        opts_banner "The banner"
+        opts_description "The description"
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--help']).run }.must_output("The banner\n\nThe description")
+      end
+    end
+
+    it 'is not required' do
+      vincent = Class.new(TestDiesel) do
+        opts_banner "My banner"
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--help']).run }.must_output("My banner")
+      end
+    end
+
+    it 'prints in order specified, on separate lines' do
+      vincent = Class.new(TestDiesel) do
+        opts_banner "My Banner"
+
+        opts_description "description 1"
+        opts_description "description 2"
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--help']).run }.must_output("description 1\ndescription 2")
+      end
+    end
+  end
+
+  describe "opts_required" do
+    it 'raises an error if option not given during execution' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-r', '--required OPTION', 'A required option' do |value|
+          options.required = value
+        end
+
+        opts_required :required
+      end
+
+      swallow_exit do
+        lambda { vincent.new([]) }.must_output("!! missing argument: --required - Run with --help for help")
+      end
+    end
+
+    it 'allows for more than one required option at a time' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-r', '--required OPTION', 'A required option' do |value|
+          options.required = value
+        end
+
+        opts_on '-o', '--option OPTION', 'Another required option' do |value|
+          options.option = value
+        end
+
+        opts_required :required, :option
+      end
+
+      swallow_exit do
+        -> { vincent.new([]) }.must_output "!! missing argument: --required"
+        -> { vincent.new(['--required', 'test']) }.must_output "!! missing argument: --option"
+      end
+    end
+
+    it 'allows for more than one required option, specified in different calls' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-r', '--required OPTION', 'A required option' do |value|
+          options.required = value
+        end
+
+        opts_on '-o', '--option OPTION', 'Another required option' do |value|
+          options.option = value
+        end
+
+        opts_required :required
+        opts_required :option
+      end
+
+      swallow_exit do
+        -> { vincent.new([]) }.must_output "!! missing argument: --required"
+        -> { vincent.new(['--required', 'test']) }.must_output "!! missing argument: --option"
+      end
+    end
+  end
+
+  describe "opts_accessor" do
+    it 'sets an attribute_reader for the given option' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-o', '--option [OPTION]', 'An option' do |value|
+          options.option = value
+        end
+
+        opts_accessor :option
+      end
+
+      swallow_exit do
+        vincent.new(['--option', 'value']).option.must_equal('value')
+      end
+    end
+
+    it 'allows for more than one option accessor at one time' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-o', '--option [OPTION]', 'An option' do |value|
+          options.option = value
+        end
+
+        opts_on '-a', '--another-option [OPTION]', 'Another option' do |value|
+          options.another_option = value
+        end
+
+        opts_accessor :option, :another_option
+      end
+
+      swallow_exit do
+        vincent.new(['--option', 'value']).option.must_equal('value')
+        vincent.new(['--another-option', 'value']).another_option.must_equal('value')
+      end
+    end
+
+    it 'allows for more than one option accessor, specified in different calls' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-o', '--option [OPTION]', 'An option' do |value|
+          options.option = value
+        end
+
+        opts_on '-a', '--another-option [OPTION]', 'Another option' do |value|
+          options.another_option = value
+        end
+
+        opts_accessor :option
+        opts_accessor :another_option
+      end
+
+      swallow_exit do
+        vincent.new(['--option', 'value']).option.must_equal('value')
+        vincent.new(['--another-option', 'value']).another_option.must_equal('value')
+      end
+    end
+
+  end
+
+  describe "opts_on" do
+    it 'outputs help for the option with the --help flag' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-f', '--flag', 'A boolean flag' do |value|
+          options.flag = value
+        end
+      end
+
+      swallow_exit do
+        lambda { vincent.new(['--help']).run }.must_output("A boolean flag")
+      end
+    end
+
+    it 'allows boolean options' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-b', '--boolean-flag', 'A boolean flag' do |value|
+          options.flag = value
+        end
+
+        run do
+          puts "flag: #{flag}"
+        end
+      end
+
+      swallow_exit do
+        vbomb = vincent.new(['--boolean-flag'])
+        vbomb.instance_variable_get(:@options).flag.must_equal(true)
+      end
+    end
+
+    it 'allows options with user supplied values' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-u', '--user-specified [OPTION]', 'A user specified option' do |value|
+          options.user_specified = value
+        end
+
+        run do
+          puts "user_specified: #{options.user_specified}"
+        end
+      end
+
+      swallow_exit do
+        vbomb = vincent.new(['--user-specified', 'option'])
+        vbomb.instance_variable_get(:@options).user_specified.must_equal('option')
+      end
+    end
+
+    it 'accepts a short flag' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-s', '--short [OPTION]', 'A short option' do |value|
+          options.short = value
+        end
+      end
+
+      swallow_exit do
+        vbomb = vincent.new(['-s', 'short'])
+        vbomb.instance_variable_get(:@options).short.must_equal('short')
+      end
+    end
+
+    it 'accepts a long flag' do
+      vincent = Class.new(TestDiesel) do
+        opts_on '-l', '--long [OPTION]', 'A long flag' do |value|
+          options.long = value
+        end
+      end
+
+      swallow_exit do
+        vbomb = vincent.new(['--long', 'long'])
+        vbomb.instance_variable_get(:@options).long.must_equal('long')
+      end
+    end
+  end
+
+  describe "dry_run flag" do
+    it 'sets the `dry_run` var to true' do
+      vincent = Class.new(TestDiesel)
+
+      swallow_exit do
+        vincent.new(['--dry-run']).dry_run.must_equal(true)
+      end
+    end
+  end
+
+  describe "verbose flag" do
+    it 'sets the `verbose` var to true' do
+      swallow_exit do
+        TestDiesel.new(['--verbose']).verbose.must_equal(true)
+      end
+    end
+
+    it 'allows info messages to be printed' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          info_message "An info message"
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("** An info message\n")
+      end
+    end
+
+    it 'allows messages from `message` to be printed' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          message "A message"
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("A message\n")
+      end
+    end
+  end
+
+  describe "post_initialize" do
+    it 'runs before `run`' do
+      vincent = Class.new(TestDiesel) do
+        post_initialize do
+          message "post-initialize"
+        end
+
+        run do
+          message "run"
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("post-initialize\nrun\n")
+      end
+    end
+  end
+
+  describe "message" do
+    it 'prints messages when verbose is true' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          message "A message"
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("A message\n")
+      end
+    end
+
+    it 'does not print messages when verbose is false' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          message "A message"
+        end
+      end
+
+      output = capture_std_out do
+        swallow_exit { vincent.new([]).run }
+      end
+
+      output.to_s.wont_include("A message")
+    end
+  end
+
+  describe "info_message" do
+    it 'prepends messages with `**`' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          info_message("An info message")
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("** An info message\n")
+      end
+    end
+
+    it 'does not print messages when verbose is false' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          info_message("An info message")
+        end
+      end
+
+      output = capture_std_out do
+        swallow_exit { vincent.new([]).run }
+      end
+
+      output.to_s.wont_include("** An info message")
+    end
+
+    it 'prints messages when verbose is true' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          info_message "An info message"
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("** An info message\n")
+      end
+    end
+  end
+
+  describe "error_message" do
+    it 'prepends messages with `!!`' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          error_message("An error message")
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new(['--verbose']).run }.must_output("!! An error message\n")
+      end
+    end
+
+    it 'prints messages regardless of `verbose`' do
+      vincent = Class.new(TestDiesel) do
+        run do
+          error_message("An error message")
+        end
+      end
+
+      swallow_exit do
+        -> { vincent.new([]).run }.must_output("!! An error message\n")
+      end
+    end
+  end
+
+  describe "dry_run?" do
+    it 'returns true if the dry-run option is set' do
+      swallow_exit do
+        TestDiesel.new(['--dry-run']).dry_run?.must_equal(true)
+      end
+    end
+
+    it 'returns false if the dry-run option is not set' do
+      swallow_exit do
+        TestDiesel.new([]).dry_run?.must_equal(false)
+      end
+    end
+  end
+end

data/test/test_diesel.rb

@@ -0,0 +1,5 @@
+class TestDiesel
+  include BinDiesel
+  def run
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+require File.expand_path('../../lib/bin_diesel.rb', __FILE__)
+require 'test_diesel'
+require 'stringio'
+require 'debugger'
+
+def swallow_std_out
+  out = StringIO.new
+  $stdout = out
+  yield
+ensure
+  $stdout = STDOUT
+end
+
+def capture_std_out
+  out = StringIO.new
+  $stdout = out
+  yield
+ensure
+  $stdout = STDOUT
+  out
+end
+
+def swallow_exit
+  begin
+    yield
+  rescue SystemExit
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: bin_diesel
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew J Vargo
+- Anthony White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: minitest
+  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: debugger
+  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'
+description: ! 'Bin Diesel allows you to write scripts relying on Option Parser with
+  DSL that eliminates the boiler plate code. Define options and run. '
+email:
+- avargo@dataxu.com
+- awhite@dataxu.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Examples/purge_files.rb
+- Examples/test.rb
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin_diesel.gemspec
+- lib/bin_diesel.rb
+- lib/bin_diesel/version.rb
+- test/lib/bin_diesel/version_test.rb
+- test/lib/bin_diesel_test.rb
+- test/test_diesel.rb
+- test/test_helper.rb
+homepage: http://www.dataxu.com
+licenses:
+- New BSD License
+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.23
+signing_key: 
+specification_version: 3
+summary: Easier "bin" scripts built with Option Parser.
+test_files:
+- test/lib/bin_diesel/version_test.rb
+- test/lib/bin_diesel_test.rb
+- test/test_diesel.rb
+- test/test_helper.rb
+has_rdoc: